You are encouraged to solve this task according to the task description, using any language you may know.

All ways to include text in a language source file that's completely ignored by the compiler or interpreter.

## 360 Assembly

 * An asterisk in column one denotes a comment line* Comments may also follow any syntactically complete instruction:          LA    1,0           Comment          NOP                 Comment (after a NOP instruction)* Comments after instructions with omitted operands require a comma ","         END   ,             Comment (without comma, "Comment" assumed an operand of "END")

## 4D

Comments in 4th Dimension begin with the accent character and extend to the end of the line (until 4D version 2004).// This is a comment starting from 4D v11 and newer. Accent character is replaced by //

## 6502 Assembly

Note: syntax depends on the assembler software but use of a semicolon is fairly standard

          nop           ; comments begin with a semicolon

## 8086 Assembly

Note: syntax depends on the assembler software but use of a semicolon is fairly standard

	MOV AX, 4C00h 		; go back to DOS	INT 21h                 ; BIOS interrupt 21 base 16

## ACL2

Just like Common Lisp:

; Single line comment#| Multi-linecomment |#

## ActionScript

See Java

-- All Ada comments begin with "--" and extend to the end of the line

## Agena

# single line comment #/ multi-line comment   - ends with the "/ followed by #" terminator on the next line/# /* multi-line comment - C-style   - ends with the "* followed by /" terminator on the next line*/

## ALGOL 60

A comment in ALGOL 60 takes the place of a single instruction.

 'COMMENT' this is a first comment;'COMMENT' ****** this is a second comment ******; 

## ALGOL 68

### With Standard

Comments can be inserted in variety of ways:

 Algol68 as typically published, includes bold typeface. Quote stropping, like to Wiki markup. Case stropping, 7-bit/ascii implementations. Res stropping, detecting reserved words. Point stropping, 6-bits/byte implementations. ¢ The original way of adding your 2 cents worth to a program with the "cent" character ¢ ¢ TEXT ¢ co Style i comment co comment text comment 'co' text 'co' 'comment' text 'comment' CO text CO COMMENT text COMMENT co text co comment text comment .CO TEXT .CO .COMMENT TEXT .COMMENT # Style ii comment with the hash character # # TEXT #

Notes:

• The # test # and ¢ text ¢ comment tends to be used for inline comments. And the COMMENT text COMMENT style tends to be used to comment out entire blocks.
• The script algol68.vim can be used to highlight commented blocks while editing source code.

### With Extensions

£ This is a hash/pound comment for a UK keyboard £


## ALGOL W

Comments in Algol W can appear anywhere whitespace is allowed. A comment starts with the reserved word 'comment' and ends with the next semi-colon. Alternatively a comment can start with a percent sign and end with the next percent sign or semi-colon.

A single word in the form of an identifier following the reserved word 'end' is also a comment.

begin    comment a comment;    % another comment    ;    % and      another    %end this_word_is_also_a_comment.

## AmigaE

/* multiline commentare like C ... */-> this is a end of line comment

## AppleScript

 --This is a single line comment display dialog "ok" --it can go at the end of a line # Hash style comments are also supported (* This is a multiline comment*) (* This is a comment. --comments can be nested  (* Nested block comment *)*) 
Works with: AppleScript version 2.0
display dialog "ok" #Starting in version 2.0, end-line comments can begin with a hash

## Asymptote

// double slash to newline

When reading data files a comment character in them can be specified as comment="#" etc. See Files in the Asymptote manual.

## AutoHotkey

Msgbox, comments demo ; end of line comment/*multiline comment1multiline comment2*/

For multi-line comments, the /* and */ must be on their own separate lines. Nothing else can be on the same line.

## AutoIt

 #csEverything between the cs and and the ce is commented.Commented code is not used by the computer.#ce;individual lines after a semicolon are commented. 

## AWK

The hash symbol # start a comment; it ends at the end of line.

BEGIN { # this code does something  # do something}

## Axe

.This is a single-line comment
...This is a multi-line comment...
...If 0This is a comment only if the condition evaluates to zero...
...!If 1This is a comment only if the condition evaluates to nonzero...
...ElseThis is a comment only if the previous conditional comment was executed (and vice versa)...

## Babel

 -- This is a line-comment #    This is a block-comment    It goes until de-dent dedent: 0x42 -- The comment block above is now closed 

## BASIC

Works with: Applesoft BASIC
Works with: GW-BASIC
Works with: ZX Spectrum Basic

The only truly standard method of marking a comment in BASIC is using the REM keyword. This dates back to (at least) the late 1970's, and should work with most BASICs available today:

100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line110 PRINT "this is code": REM comment after statement
Works with: Applesoft BASIC

This may not be well known, but you may include text after the line number of GOTO and GOSUB statements. This is kind of a comment in absence of labels.

100  GOTO 200HERE
110  GOSUB 300THERE
120  GOTO 400THEOTHERPLACE
130  GOTO 500MOM AND  POP


Spaces are removed from non-keyword text. BASIC keywords can be used. List outputs spaces around keywords.

Works with: QuickBASIC version 4.5

Most BASICs also support alternate comment characters, commonly an apostrophe (single quote):

 'this is a comment PRINT "this is code"  'comment after statement
Works with: DarkBASIC

Characters other than apostrophe are used in some BASICs. For example, DarkBASIC uses a back-tick character (, a.k.a. grave accent):

this is a comment
PRINT "this is code" comment after statement
'this is NOT a comment!

Works with: FreeBASIC version 0.16 or later

In addition to single-line comments, a few BASICs support block comments. FreeBASIC was influenced by the C family's block comment characters:

/' This is a multi line comment.
Requires FreeBASIC 0.16 or later.
Last line of the comment block. '/

DIM a AS /' Comment in the middle of statement '/ Integer


## Batch File

rem Single-line comment.

There is another (unsupported) option, using a double-colon ::. However, this has issues with some syntactic constructs and therefore may raise syntax errors.

:: Another option, though unsupported and known:: to fail in some cases. Best avoided.

Since comment lines are skipped entirely by the parser multi-line comments aren't possible even with line continuation.

## BBC BASIC

      REM This is a comment which is ignored by the compiler      *| This is a comment which is compiled but ignored at run time

## bc

/* This is a comment. */ 2 + /* Comment between tokens. */ 3 "This is a string, /* NOT a comment */." /* * A comment can have multiple lines. These asterisks in the middle * of the comment are only for style. You must not nest a comment * inside another comment; the first asterisk-slash ends the comment. */

Works with: GNU bc
Works with: OpenBSD bc
#!/usr/bin/bc # This form of comment is an extension, not part of standard bc. # Your program must not have a #! shebang line# unless your bc supports this form of comment. 2 + 3  # It can be after a statement. a = 1  # The newline is not part of the comment.b = 2  # So this line is a different statement.

## Befunge

Like Brainf***, all characters and whitespace which are not commands are ignored. Also, since the code/data-space is two-dimensional, comments can be placed anywhere that will be untouched by the instruction pointer and data access commands. Finally, in Funge-98, the ; instruction immediately skips to the next ; instruction, which allows to isolate comments from code.

Works with: Befunge version 93
& read a number 2+ add two .@ display result and exit  ^- inline comments -^     <-^- other comments
Works with: Befunge version 98
&;read a number;2+;add two;.@;display result and exit;  ^- inline comments -^     <-^- other comments;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;completely isolated comment block for the paranoid;;(almost - you can still skip into it.)            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

## Blast

# A hash symbol at the beginning of a line marks the line as a comment

## Bracmat


Multi-line comments for inline documentation (Plain Old Documentation, or POD in Perl parlance) follow the format:

=pod Here are my commentsthis is multi-line =cut

Note that technically, both of the lines beginning with the equals sign must be surrounded on either side for compatibility with all "POD" parsers.

Note also that any string beginning with an equals sign, and that appears in the initial column of a line, begins a multi-line comment. It does not have to be a POD "command:" the following are all valid:

=head1=head4=over 4=Any Old String

Such blocks always end in =cut.

For more info, type at a command prompt (or into a search engine): "perldoc perlpod"

## Perl 6

my $x = 2; # Single-line comment. #( Comments beginning with a backtick and one or more opening bracketing characters are embedded comments. They can span more than one line…) my$y = #{ …or only part of a line. } 3; #{{    Using more than one bracketing character lets you include    an unmatched close bracket, like this: }}} #⁅ Synopsis 2: "Bracketing characters are defined as any    Unicode characters with either bidirectional mirrorings or    Ps/Pe/Pi/Pf properties." ⁆  =begin comment Pod is the successor to Perl 5's POD. This is the simplest wayto use it for multi-line comments. For more about Pod, seeSynopsis 26: http://perlcabal.org/syn/S26.html =end comment

## Phix

Single line comment:

-- This is a comment

/*This is a commentprocedure oldproc()   /*     This is also a comment   */   puts(1,"kill me now")end procedure*/puts(1,"this is not a comment")
Output:
this is not a comment


## PHP

Single line comment:

# this is commented// this is commented

These may also be at the end of a line:

$var = 1; # this is the comment part$var = 1; // this is the comment part

/*Here are my commentsthis is multi-line*/

Note that; it is more common to see phpDocumentor styled multi-lined comments:

/** * phpdoc Comments * @todo this is a todo stub */

## PicoLisp

# The rest of the line is ignored#{   This is a   multiline comment}#NILImmediately stop reading this file. Because all text in the input file followinga top-level 'NIL' is ignored. This is typically used conditionally, with a read-macro expression like*Dbgso that this text is only read if in debugging mode.

## Pike

// This is a comment./* This is a    multi   line   comment */ int e = 3; // end-of-statement comment.

## plainTeX

The default raw/bare TeX assigns the category code 14 (comment character) to the character %, and plainTeX, as also LaTeX (see here Comments in LaTeX, does not change it; so the % starts a to-end-of-line comment in many TeX macro packages.

% this is a commentThis is not.

The final newline character is eaten and since it normally behaves like a space, the comment can be used to hide the newline:

\def\firstpart{understand}\def\secondpart{able}\def\complete{\firstpart%\secondpart} \complete

Outputs understandable; without % it would output understand able.

## PL/I

/* This is a comment. */
/* This is a multiline comment. */

Note: In PL/I, comments cannot be nested.

## PL/SQL

Single line comment:

--this is a single line comment

Multiline comment:

/*this is a multilinecomment*/

End of line comment:

v_var NUMBER; --this is an end of line comment

## Pop11

Pop11 has two kinds of comments: endline and C-like. Endline comment begins with tree consecutive semicolons and ends at the end of line:

;;; This is a comment

/* First line   Second line */

C-like comments (unlike C) may be nested:

/* This is a comment /* containing nested comment */ */

One can also use conditional compilation to comment out sections of code

#_IF falsesome code #_ENDIF

however, commented out part must consist of valid Pop11 tokens. In particular, C-like comments must balance and strings must be terminated. The following is an error:

#_IF falseThis w'ont work#_ENDIF

because apostrophe starts an unterminated string.

## PostScript

 %This is a legal comment in PostScript

## PowerShell

# single-line comment
Works with: PowerShell version 2
<# multi-line   comment #>

## ProDOS

I don't know why this is even a task because it should be included in any decent programming language.

IGNORELINE your text here

## Prolog

% this is a single-line comment that extends to the end of the line
/* This is amulti-line comment */

## Protium

Protium encloses all comments inside <@ OMT></@> (fixed length opcode) or <# OMIT></#> (variable length opcode) whether single- or multi- line.

 <@ OMT>This is amultilinecomment</@>

OMT suppresses evaluation of everything contained. There are a variety of extra opcodes which can be used to control how OMT functions at run time.

## PureBasic

PureBasic uses the ";" symbol to mark its comments. All text entered after ";" on a line is ignored by the compiler.

## Sidef

Single line comment

# this is commented

These may also be at the end of a line

var i = 1; # this is the comment part

var distance #{in meters} = (30 #{meters} * 100 #{seconds});say distance; # prints: 3000

/*    This is a multi-line comment*/

## Simula

The same as Algol 60:

COMMENT This is a comment for Simula 67;

And an new form:

!This is a comment for Simula 67;

## Slate

"basically the same as smalltalk"

## Smalltalk

"Comments traditionally are in double quotes.""Multiline comments are also supported. Comments are saved as metadata along with the source to a method. A comment just after a method signature is often given to explain the usage of the method. The class browser may display such comments specially."

## SNOBOL4

 * An asterisk in column 1 is the standard Snobol comment* mechanism, marking the entire line as a comment. There* are no block or multiline comments. *               Comments may begin at*               any position on the line. - A hyphen in column 1 begins a control statement. - Unrecognized control statements are ignored and- may also mark comment lines. Not recommended.                    ;* The semicolon statement separator    output = 'FOO' ;* begins a new statement. This idiom    output = 'BAR' ;* simulates an asterisk in the first                   ;* column, allowing end of line comments. END Any text after the required END label is ignored.

## SNUSP

As with Brainf*** and Befunge, any character that is not part of the language is ignored and can be used as commentary, and you can add comments anywhere the instruction pointer is not expected to traverse. Reserved characters are:

## TXR

@# old-style comment to end of line@; new-style comment to end of line@(bind a ; comment within expression       "foo")

## UNIX Shell

Works with: Bourne Shell
Works with: Korn Shell
#!/bin/sh# A leading hash symbol begins a comment.echo "Hello"      # Comments can appear after a statement. # The hash symbol must be at the beginning of a word.echo This_Is#Not_A_Comment#Comment

### C Shell

#!/bin/csh -f # C Shell has a similar comment syntax, but only allows comments in a# script file, not in terminal input. echo Hello#With C Shell, the hash can also be in the middle of a word.

### es

# Comments in es (extensible shell) look like those of other shells. echo Hello#With es, the hash can also be in the middle of a word.

## Unlambda

Unlambda comments start with # and extend to the end of the line:

# this is a comment.


Note that comments don't need to start at the beginning of a line, e.g.

  # apply
.a # output "a"
i  # identity


is equivalent to

.ai


## Ursala

There are lots of ways to have comments in Ursala. Here are the conventional ones.

# this is single line a comment # this is a\continued comment (# this is amulti-line comment #) (# comments in (# this form #) can (# be (# arbitrarily #) #) nested #) ---- this is also a comment\and can be continued ###The whole rest of the file after three hashesis a comment.

### Commenting out code

There are also ways to comment out sections of code during testing. An individual item of a syntactically correct list or aggregate is commented out like this.

x = <1,## 2,3>

The 2 is ignored but 1 and 3 aren't. This also works with nested aggregates and multiple lines.

a = <   'to',   ## <      'be',      'or'>,   'not',   'to',   ## 'be'>

A syntactically correct declaration can be commented out like this.

foo = 1 ## bar = 2 baz = 3

As far as the compiler is concerned, bar is not defined, but foo and baz are. It wouldn't matter if bar took multiple lines.

The compiler can be directed to embed comments in executable files and libraries it generates without affecting their semantics.

#comment -[I document the source text but will also be embedded inthe output library or executable file.]- #comment gpl'3'

The latter comment puts the standard GPL license notification in the output file.

A function f annotated with a crash dump wrapper expressed like this during debugging

my_input_type%C f

is equivalent to just f when changed to this in the production code.

my_input_type%Ck f

Compiling with the --depend command line option makes the compiler only scan for the #depend'ed expressions and send them to standard output.

#depend <this,expression> is (parsed)* but {   otherwise,   ignored}

This way, scripts and source management tools can have information passed to them from the programmer by running the compiler instead of re-implementing their own parsers.

## VBA

A comment starts with a quote (') and it ends at end of line

' This is a VBA comment

## VBScript

A comment starts with a quote (') and it ends at end of line

' This is a VBScript comment

## Verilog

// Single line commment. /*    Multiple   line   comment.*/

## VHDL

-- Single line commment in VHDL

## Vim Script

All lines starting with " are comments and will be ignored.

In most cases, " will also work after a command (i.e. the rest of the line will be ignored). But some commands like echo treat the whole line as their argument and thus will raise an error (Missing quote).

let a = 4 " A valid commentecho "foo" " Not a comment but an argument that misses the closing quote

## Visual Basic

In addition to the methods mentioned in BASIC above, it is also somewhat common to effectively comment out code by including the unwanted code inside an #If 0 ... #End If block. (This works because 0 evaluates to False in VB.) Note, however, that the IDE will complain about actual comments inside an #If 0 block unless it's also commented normally (i.e., using Rem or ').

'commentRem comment#If 0  Technically not a comment; the compiler may or may not ignore this, but the  IDE won't. Note the somewhat odd formatting seen here; the IDE will likely  just mark the entire line(s) as errors.#End If

## Visual Basic .NET

Visual Basic .NET uses the "'" symbol or "REM" to mark it's comments. After placing a "'", or "REM", everything in that line will be ignored.

' This is a commentREM This is also a commentDim comment as string ' You can also append comments to statementsDim comment2 as string REM You can append comments to statements

## Vorpal

# single line comment

## Wart

# single line comment

## XPL0

Comments are enclosed in backslash characters, but the end of a line always terminates a comment. Consequently there is no multi-line comment. For example:

Text(0, \comment\ "Hello \not a comment\ World!"); \comment

Since backslashes toggle comments on and off, it could be inconvenient to comment out a line of code that contains a comment. For example, two additional backslashes could be used to comment out this line, as shown here:

 Text(0, "Hello World");  \comment\Text(0, "Hello World"); \\comment

However, two backslashes together comment out everything to the end of the line regardless of any backslashes the line might contain. So the first example could be commented out like this:

\\Text(0, \comment\ "Hello \not a comment\ World"); \comment

Conditional compilation can be used to effectively comment out multiple lines of code. For example:

cond false;Text(0, "Hello World"); \commentCrLf(0);cond true;

## XQuery

(: This is a XQuery comment :)

## XSLT

<!-- Comment syntax is borrowed from XML and HTML. -->

## XUL

<!-- Comment syntax is borrowed from XML and HTML. -->

## zkl

x=1; // comment ala C++x=2; # ala scripts/* ala C, these comments are parsed (also ala C) *//* can /* be */ nested */#if 0  also ala C (and parsed)#endif#<<<#  "here" comment, unparsed#<<<#`