Primary Expression

this

null

    42

(1 + 2 ) * 3

Grouping Operator

(1) + (2  ) + 3

4 + 5 << (6)

Array Initializer

x = []

x = [ ]

x = [ 42 ]

x = [ 42, ]

x = [ ,, 42 ]

x = [ 1, 2, 3, ]

x = [ 1, 2,, 3, ]

x = [ "finally", "for" ]

日本語 = []

T‿ = []

T‌ = []

T‍ = []

ⅣⅡ = []

ⅣⅡ = []

[",", "second"]

["notAToken", "if"]

Object Initializer

x = {}

x = { }

x = { answer: 42 }

x = { if: 42 }

x = { true: 42 }

x = { false: 42 }

x = { null: 42 }

x = { "answer": 42 }

x = { x: 1, x: 2 }

x = { get width() { return m_width } }

x = { get undef() {} }

x = { get if() {} }

x = { get true() {} }

x = { get false() {} }

x = { get null() {} }

x = { get "undef"() {} }

x = { get 10() {} }

x = { set width(w) { m_width = w } }

x = { set if(w) { m_if = w } }

x = { set true(w) { m_true = w } }

x = { set false(w) { m_false = w } }

x = { set null(w) { m_null = w } }

x = { set "null"(w) { m_null = w } }

x = { set 10(w) { m_null = w } }

x = { get: 42 }

x = { set: 43 }

x = { __proto__: 2 }

x = {"__proto__": 2 }

x = { get width() { return m_width }, set width(width) { m_width = width; } }

Comments

/* block comment */ 42

42 /*The*/ /*Answer*/

42 /*the*/ /*answer*/

42 /* the * answer */

42 /* The * answer */

/* multiline
comment
should
be
ignored */ 42

/*a
b*/ 42

/*a
b*/ 42

/*a
b*/ 42

/*a
c*/ 42

// line comment
42

42 // line comment

// Hello, world!
42

// Hello, world!

// Hallo, world!

//
42

//

// 

/**/42

// Hello, world!

//   Another hello
42

if (x) { // Some comment
doThat(); }

switch (answer) { case 42: /* perfect */ bingo() }

Numeric Literals

0

3

5

42

.14

3.14159

6.02214179e+23

1.492417830e-10

0x0

0x0;

0e+100 

0e+100

0xabc

0xdef

0X1A

0x10

0x100

0X04

02

012

0012

String Literals

"Hello"

"\n\r\t\v\b\f\\\'\"\0"

"\u0061"

"\x61"

"\u00"

"\xt"

"Hello\nworld"

"Hello\
world"

"Hello\02World"

"Hello\012World"

"Hello\122World"

"Hello\0122World"

"Hello\312World"

"Hello\412World"

"Hello\812World"

"Hello\712World"

"Hello\0World"

"Hello\
world"

"Hello\1World"

Regular Expression Literals

var x = /[a-z]/i

var x = /[x-z]/i

var x = /[a-c]/i

var x = /[P QR]/i

var x = /foo\/bar/

var x = /=([^=\s])+/g

var x = /[P QR]/\u0067

var x = /[P QR]/\g

var x = /42/g.test

Left-Hand-Side Expression

new Button

new Button()

new new foo

new new foo()

new foo().bar()

new foo[bar]

new foo.bar()

( new foo).bar()

foo(bar, baz)

(    foo  )()

universe.milkyway

universe.milkyway.solarsystem

universe.milkyway.solarsystem.Earth

universe[galaxyName, otherUselessName]

universe[galaxyName]

universe[42].galaxies

universe(42).galaxies

universe(42).galaxies(14, 3, 77).milkyway

earth.asia.Indonesia.prepareForElection(2014)

universe.if

universe.true

universe.false

universe.null

Postfix Expressions

x++

x--

eval++

eval--

arguments++

arguments--

Unary Operators

++x

--x

++eval

--eval

++arguments

--arguments

+x

-x

~x

!x

void x

delete x

typeof x

Multiplicative Operators

x * y

x / y

x % y

Additive Operators

x + y

x - y

"use strict" + 42

Bitwise Shift Operator

x << y

x >> y

x >>> y

Relational Operators

x < y

x > y

x <= y

x >= y

x in y

x instanceof y

x < y < z

Equality Operators

x == y

x != y

x === y

x !== y

Binary Bitwise Operators

x & y

x ^ y

x | y

Binary Expressions

x + y + z

x - y + z

x + y - z

x - y - z

x + y * z

x + y / z

x - y % z

x * y * z

x * y / z

x * y % z

x % y * z

x << y << z

x | y | z

x & y & z

x ^ y ^ z

x & y | z

x | y ^ z

x | y & z

Binary Logical Operators

x || y

x && y

x || y || z

x && y && z

x || y && z

x || y ^ z

Conditional Operator

y ? 1 : 2

x && y ? 1 : 2

Assignment Operators

x = 42

eval = 42

arguments = 42

x *= 42

x /= 42

x %= 42

x += 42

x -= 42

x <<= 42

x >>= 42

x >>>= 42

x &= 42

x ^= 42

x |= 42

Complex Expression

a || b && c | d ^ e & f == g < h >>> i + j * k

Block

{ foo }

{ doThis(); doThat(); }

{}

Variable Statement

var x

var x, y;

var x = 42

var eval = 42, arguments = 42

var x = 14, y = 3, z = 1977

var implements, interface, package

var private, protected, public, static

Let Statement

let x

{ let x }

{ let x = 42 }

{ let x = 14, y = 3, z = 1977 }

Const Statement

const x = 42

{ const x = 42 }

{ const x = 14, y = 3, z = 1977 }

Empty Statement

;

Expression Statement

x

x, y

\u0061

a\u0061

\u0061a

\u0061a 

If Statement

if (morning) goodMorning()

if (morning) (function(){})

if (morning) var x = 0;

if (morning) function a(){}

if (morning) goodMorning(); else goodDay()

Iteration Statements

do keep(); while (true)

do keep(); while (true);

do { x++; y--; } while (x < 10)

{ do { } while (false) false }

while (true) doSomething()

while (x < 10) { x++; y--; }

for(;;);

for(;;){}

for(x = 0;;);

for(var x = 0;;);

for(let x = 0;;);

for(var x = 0, y = 1;;);

for(x = 0; x < 42;);

for(x = 0; x < 42; x++);

for(x = 0; x < 42; x++) process(x);

for(x in list) process(x);

for (var x in list) process(x);

for (let x in list) process(x);

for (var i = function() { return 10 in [] } of list) process(x);

continue statement

while (true) { continue; }

while (true) { continue }

done: while (true) { continue done }

done: while (true) { continue done; }

__proto__: while (true) { continue __proto__; }

break statement

while (true) { break }

done: while (true) { break done }

done: while (true) { break done; }

__proto__: while (true) { break __proto__; }

return statement

(function(){ return })

(function(){ return; })

(function(){ return x; })

(function(){ return x * y })

with statement

with (x) foo = bar

with (x) foo = bar;

with (x) { foo = bar }

switch statement

switch (x) {}

switch (answer) { case 42: hi(); break; }

switch (answer) { case 42: hi(); break; default: break }

Labelled Statements

start: for (;;) break start

start: while (true) break start

__proto__: test

throw statement

throw x;

throw x * y

throw { message: "Error" }

try statement

try { } catch (e) { }

try { } catch (eval) { }

try { } catch (arguments) { }

try { } catch (e) { say(e) }

try { } finally { cleanup(stuff) }

try { doThat(); } catch (e) { say(e) }

try { doThat(); } catch (e) { say(e) } finally { cleanup(stuff) }

debugger statement

debugger;

Function Definition

function hello() { sayHi(); }

function eval() { }

function arguments() { }

function test(t, t) { }

(function test(t, t) { })

function eval() { function inner() { "use strict" } }

function hello(a) { sayHi(); }

function hello(a, b) { sayHi(); }

var hi = function() { sayHi() };

var hi = function eval() { };

var hi = function arguments() { };

var hello = function hi() { sayHi() };

(function(){})

function universe(__proto__) { }

function test() { "use strict" + 42; }

Automatic semicolon insertion

{ x
++y }

{ x
--y }

var x /* comment */;

{ var x = 14, y = 3
z; }

while (true) { continue
there; }

while (true) { continue // Comment
there; }

while (true) { continue /* Multiline
Comment */there; }

while (true) { break
there; }

while (true) { break // Comment
there; }

while (true) { break /* Multiline
Comment */there; }

(function(){ return
x; })

(function(){ return // Comment
x; })

(function(){ return/* Multiline
Comment */x; })

{ throw error
error; }

{ throw error// Comment
error; }

{ throw error/* Multiline
Comment */error; }

Source elements

Source option

x + y - z

a + (b < (c * d)) + e

Invalid syntax

{

}

3ea

3in []

3e

3e+

3e-

3x

3x0

0x

09

018

01a

3in[]

0x3in[]

"Hello
World"

x\

x\u005c

x\u002a

var x = /(s/g

a\u

\ua

/

/test

var x = /[a-z]/\ux

3 = 4

func() = 4

(1 + 1) = 10

1++

1--

++1

--1

for((1 + 1) in list) process(x);

[

[,

1 + {

1 + { t:t 

1 + { t:t,

var x = /
/

var x = "

var if = 42

i #= 42

i + 2 = 42

+i = 42

1 + (

{

/* Some multiline
comment */
)

{ set 1 }

{ get 2 }

({ set: s(if) { } })

({ set s(.) { } })

({ set: s() { } })

({ set: s(a, b) { } })

({ get: g(d) { } })

({ get i() { }, i: 42 })

({ i: 42, get i() { } })

({ set i(x) { }, i: 42 })

({ i: 42, set i(x) { } })

({ get i() { }, get i() { } })

({ set i(x) { }, set i(x) { } })

function t(if) { }

function t(true) { }

function t(false) { }

function t(null) { }

function null() { }

function true() { }

function false() { }

function if() { }

a b;

if.a;

a if;

a class;

break

break 1;

continue

continue 2;

throw

throw;

throw

for (var i, i2 in {});

for ((i in {}));

for (i + 1 in {});

for (+i in {});

if(false)

if(false) doThis(); else

do

while(false)

for(;;)

with(x)

try { }

‿ = 10

const x = 12, y;

const x, y = 12;

const x;

if(true) let a = 1;

if(true) const a = 1;

switch (c) { default: default: }

new X()."s"

/*

/*

/**

/*

*

/*hello

/*hello  *

]

]

]

]

//
]

//

]

/a\
/

//
 
]

/*
*/]

/*

*/]

/*
 
*/]

\\

\u005c

\x

\u0000

‌ = []

‍ = []

"\

"\u

try { } catch() {}

return

break

continue

switch (x) { default: continue; }

do { x } *

while (true) { break x; }

while (true) { continue x; }

x: while (true) { (function () { break x; }); }

x: while (true) { (function () { continue x; }); }

x: while (true) { (function () { break; }); }

x: while (true) { (function () { continue; }); }

x: while (true) { x: while (true) { } }

(function () { 'use strict'; delete i; }())

(function () { 'use strict'; with (i); }())

function hello() {'use strict'; ({ i: 42, i: 42 }) }

function hello() {'use strict'; ({ hasOwnProperty: 42, hasOwnProperty: 42 }) }

function hello() {'use strict'; var eval = 10; }

function hello() {'use strict'; var arguments = 10; }

function hello() {'use strict'; try { } catch (eval) { } }

function hello() {'use strict'; try { } catch (arguments) { } }

function hello() {'use strict'; eval = 10; }

function hello() {'use strict'; arguments = 10; }

function hello() {'use strict'; ++eval; }

function hello() {'use strict'; --eval; }

function hello() {'use strict'; ++arguments; }

function hello() {'use strict'; --arguments; }

function hello() {'use strict'; eval++; }

function hello() {'use strict'; eval--; }

function hello() {'use strict'; arguments++; }

function hello() {'use strict'; arguments--; }

function hello() {'use strict'; function eval() { } }

function hello() {'use strict'; function arguments() { } }

function eval() {'use strict'; }

function arguments() {'use strict'; }

function hello() {'use strict'; (function eval() { }()) }

function hello() {'use strict'; (function arguments() { }()) }

(function eval() {'use strict'; })()

(function arguments() {'use strict'; })()

function hello() {'use strict'; ({ s: function eval() { } }); }

(function package() {'use strict'; })()

function hello() {'use strict'; ({ i: 10, set s(eval) { } }); }

function hello() {'use strict'; ({ set s(eval) { } }); }

function hello() {'use strict'; ({ s: function s(eval) { } }); }

function hello(eval) {'use strict';}

function hello(arguments) {'use strict';}

function hello() { 'use strict'; function inner(eval) {} }

function hello() { 'use strict'; function inner(arguments) {} }

 "\1"; 'use strict';

function hello() { 'use strict'; "\1"; }

function hello() { 'use strict'; 021; }

function hello() { 'use strict'; ({ "\1": 42 }); }

function hello() { 'use strict'; ({ 021: 42 }); }

function hello() { "octal directive\1"; "use strict"; }

function hello() { "octal directive\1"; "octal directive\2"; "use strict"; }

function hello() { "use strict"; function inner() { "octal directive\1"; } }

function hello() { "use strict"; var implements; }

function hello() { "use strict"; var interface; }

function hello() { "use strict"; var package; }

function hello() { "use strict"; var private; }

function hello() { "use strict"; var protected; }

function hello() { "use strict"; var public; }

function hello() { "use strict"; var static; }

function hello() { "use strict"; var yield; }

function hello() { "use strict"; var let; }

function hello(static) { "use strict"; }

function static() { "use strict"; }

function eval(a) { "use strict"; }

function arguments(a) { "use strict"; }

var yield

var let

"use strict"; function static() { }

function a(t, t) { "use strict"; }

function a(eval) { "use strict"; }

function a(package) { "use strict"; }

function a() { "use strict"; function b(t, t) { }; }

(function a(t, t) { "use strict"; })

function a() { "use strict"; (function b(t, t) { }); }

(function a(eval) { "use strict"; })

(function a(package) { "use strict"; })

__proto__: __proto__: 42;

"use strict"; function t(__proto__, __proto__) { }

"use strict"; x = { __proto__: 42, __proto__: 43 }

"use strict"; x = { get __proto__() { }, __proto__: 43 }

var

let

const

{ ;  ;  

function t() { ;  ;  

Tokenize

tokenize(/42/)

if (false) { /42/ }

with (false) /42/

(false) /42/

function f(){} /42/

function(){} /42

{} /42

[function(){} /42]

;function f(){} /42/

void /42/

/42/

foo[/42]

/42

foo[/42

API

parse()

parse(null)

parse(42)

parse(true)

parse(undefined)

parse(new String("test"))

parse(new Number(42))

parse(new Boolean(true))

Syntax

tokenize()

tokenize(null)

tokenize(42)

tokenize(true)

tokenize(undefined)

tokenize(new String("test"))

tokenize(new Number(42))

tokenize(new Boolean(true))

Tolerant parse

return

(function () { 'use strict'; with (i); }())

(function () { 'use strict'; 021 }())

"use strict"; delete x

"use strict"; try {} catch (eval) {}

"use strict"; try {} catch (arguments) {}

"use strict"; var eval;

"use strict"; var arguments;

"use strict"; eval = 0;

"use strict"; eval++;

"use strict"; --eval;

"use strict"; arguments = 0;

"use strict"; arguments--;

"use strict"; ++arguments;

"use strict";x={y:1,y:1}

"use strict"; function eval() {};

"use strict"; function arguments() {};

"use strict"; function interface() {};

"use strict"; (function eval() {});

"use strict"; (function arguments() {});

"use strict"; (function interface() {});

"use strict"; function f(eval) {};

"use strict"; function f(arguments) {};

"use strict"; function f(foo,  foo) {};

"use strict"; (function f(eval) {});

"use strict"; (function f(arguments) {});

"use strict"; (function f(foo,  foo) {});

"use strict"; x = { set f(eval) {} }

function hello() { "octal directive\1"; "use strict"; }

"\1"; 'use strict';

"use strict"; var x = { 014: 3}

"use strict"; var x = { get i() {}, get i() {} }

"use strict"; var x = { i: 42, get i() {} }

"use strict"; var x = { set i(x) {}, i: 42 }

ES6 Unicode Code Point Escape Sequence

"\u{714E}\u{8336}"

"\u{20BB7}\u{91CE}\u{5BB6}"

ES6: Numeric Literal

00

0o0

function test() {'use strict'; 0o0; }

0o2

0o12

0O0

function test() {'use strict'; 0O0; }

0O2

0O12

0b0

0b1

0b10

0B0

0B1

0B10

ES6 Template Strings

`42`

raw`42`

raw`hello ${name}`

`$`

`\n\r\b\v\t\f\
\
`

`

`

`\u{000042}\u0042\x42\u0\102\A`

new raw`42`

ES6: Switch Case Declaration

switch (answer) { case 42: let t = 42; break; }

ES6: Arrow Function

() => "test"

e => "test"

(e) => "test"

(a, b) => "test"

e => { 42; }

e => ({ property: 42 })

e => { label: 42 }

(a, b) => { 42; }

([a, , b]) => 42

([a.a]) => 42

(x=1) => x * x

eval => 42

arguments => 42

(a) => 00

(eval, a) => 42

(eval = 10) => 42

(eval, a = 10) => 42

(x => x)

x => y => 42

(x) => ((y, z) => (x, y, z))

foo(() => {})

foo((x, y) => {})

ES6: Method Definition

x = { method() { } }

x = { method(test) { } }

x = { 'method'() { } }

x = { get() { } }

x = { set() { } }

x = { method() 42 }

x = { get method() 42 }

x = { set method(val) v = val }

Array Comprehension

[[x,b,c] for (x in []) for (b in []) if (b && c)]

[x for (a in [])]

[1 for (x in [])]

[(x,1) for (x in [])]

[x for (x of array)]

[x for (x of array) for (y of array2) if (x === test)]

Harmony: Object Literal Property Value Shorthand

x = { y, z }

Harmony: Destructuring

[a, b] = [b, a]

({ responseText: text }) = res

const {a} = {}

const [a] = []

let {a} = {}

let [a] = []

var {a} = {}

var [a] = []

const {a:b} = {}

let {a:b} = {}

var {a:b} = {}

Harmony: Modules

module "crypto" {}

module crypto from "crypto";

module "crypto/e" {}

export var document

export var document = { }

export let document

export let document = { }

export const document = { }

export function parse() { }

export class Class {}

export default = 42

export *

export * from "crypto"

export { encrypt }

export { encrypt, decrypt }

export { encrypt as default }

export { encrypt, decrypt as dec }

module "lib" { export var document }

module "lib" { export var document = { } }

module "lib" { export let document }

module "lib" { export let document = { } }

module "lib" { export const document = { } }

module "lib" { export function parse() { } }

module "lib" { export class Class {} }

module "lib" { export * }

module "security" { export * from "crypto" }

module "crypto" { export { encrypt } }

module "crypto" { export { encrypt, decrypt } }

module "crypto" { export { encrypt, decrypt as dec } }

import "jquery"

import $ from "jquery"

import { encrypt, decrypt } from "crypto"

import { encrypt as enc } from "crypto"

import { decrypt, encrypt as enc } from "crypto"

import default from "foo"

import { null as nil } from "bar"

module "security" { import "cryto" }

module()

module "foo" { module() }

Harmony: Yield Expression

(function* () { yield v })

(function* () { yield *v })

function* test () { yield *v }

var x = { *test () { yield *v } };

function* t() {}

(function* () { yield yield 10 })

Harmony: Iterators

for(x of list) process(x);

for (var x of list) process(x);

for (var x = 42 of list) process(x);

for (let x of list) process(x);

Harmony: Class (strawman)

var A = class extends B {}

class A extends class B extends C {} {}

class A {get() {}}

class A { static get() {}}

class A extends B {get foo() {}}

class A extends B { static get foo() {}}

class A {set a(v) {}}

class A { static set a(v) {}}

class A {set(v) {};}

class A { static set(v) {};}

class A {*gen(v) { yield v; }}

class A { static *gen(v) { yield v; }}

"use strict"; (class A {constructor() { super() }})

class A {static foo() {}}

class A {foo() {} static bar() {}}

"use strict"; (class A { static constructor() { super() }})

class A { foo() {} bar() {}}

class A { get foo() {} set foo(v) {}}

class A { static get foo() {} get foo() {}}

class A { static get foo() {} static get bar() {} }

class A { static get foo() {} static set foo(v) {} get foo() {} set foo(v) {}}

class A { set foo(v) {} get foo() {} }

class A { get foo() {} get foo() {} }

class A { set foo(v) {} set foo(v) {} }

class A { get foo() {} foo() {} }

class A { foo() {} get foo() {} }

class A { set foo(v) {} foo() {} }

class A { foo() {} set foo(v) {} }

ES6: Default parameters

x = function(y = 1) {}

function f(a = 1) {}

x = { f: function(a=1) {} }

x = { f(a=1) {} }

ES6: Rest parameters

function f(a, ...b) {}

ES6: Destructured Parameters

function x([ a, b ]){}

function x({ a, b }){}

function x(a, { a }){}

function x(...[ a, b ]){}

function x({ a: { w, x }, b: [y, z] }, ...[a, b, c]){}

(function x([ a, b ]){})

(function x({ a, b }){})

(function x(...[ a, b ]){})

(function x({ a: { w, x }, b: [y, z] }, ...[a, b, c]){})

({ x([ a, b ]){} })

({ x(...[ a, b ]){} })

({ x({ a: { w, x }, b: [y, z] }, ...[a, b, c]){} })

(...a) => {}

(a, ...b) => {}

({ a }) => {}

({ a }, ...b) => {}

(...[a, b]) => {}

(a, ...[b]) => {}

({ a: [a, b] }, ...c) => {}

({ a: b, c }, [d, e], ...f) => {}

ES6: SpreadElement

[...a] = b

[a, ...b] = c

[{ a, b }, ...c] = d

[a, ...[b, c]] = d

var [...a] = b

var [a, ...b] = c

var [{ a, b }, ...c] = d

var [a, ...[b, c]] = d

func(...a)

func(a, ...b)

Harmony Invalid syntax

0o

0o1a

0o9

0o18

0O

0O1a

0O9

0O18

0b

0b1a

0b9

0b18

0b12

0B

0B1a

0B9

0B18

0B12

"\u{110000}"

"\u{}"

"\u{FFFF"

"\u{FFZ}"

[v] += ary

[2] = 42

({ obj:20 }) = 42

( { get x() {} } ) = 0

x 
 is y

x 
 isnt y

function default() {}

function hello() {'use strict'; ({ i: 10, s(eval) { } }); }

function a() { "use strict"; ({ b(t, t) { } }); }

var super

var default

let default

const default

({ v: eval }) = obj

({ v: arguments }) = obj

for (var i = function() { return 10 in [] } in list) process(x);

for (let x = 42 in list) process(x);

for (let x = 42 of list) process(x);

module
"crypto" {}

module foo from bar

module 42

module foo bar

module "crypto" { module "e" {} }

module "x" { export * from foo }

import foo

import { foo, bar }

import foo from bar

((a)) => 42

(a, (b)) => 42

"use strict"; (eval = 10) => 42

"use strict"; eval => 42

"use strict"; arguments => 42

"use strict"; (eval, a) => 42

"use strict"; (arguments, a) => 42

"use strict"; (eval, a = 10) => 42

(a, a) => 42

"use strict"; (a, a) => 42

"use strict"; (a) => 00

() <= 42

(10) => 00

(10, 20) => 00

yield v

yield 10

yield* 10

e => yield* 10

(function () { yield 10 })

(function () { yield* 10 })

(function* () { })

function* test () { }

var obj = { *test() { } }

var obj = { *test** }

class A extends yield B { }

class default

`test

switch `test`

`hello ${10 `test`

`hello ${10;test`

function a() 1 // expression closure is not supported

[a,b if (a)] // (a,b)

for each (let x in {}) {};

[x for (let x in [])]

[x for (const x in [])]

[x for (var x in [])]

[a,b for (a in [])] // (a,b) 

[x if (x)]  // block required

var a = [x if (x)]

[for (x in [])]  // no espression

({ "chance" }) = obj

({ 42 }) = obj

function f(a, ...b, c)

function f(a, ...b = 0)

function x(...{ a }){}

"use strict"; function x(a, { a }){}

"use strict"; function x({ b: { a } }, [{ b: { a } }]){}

"use strict"; function x(a, ...[a]){}

(...a, b) => {}

([ 5 ]) => {}

({ 5 }) => {}

(...[ 5 ]) => {}

[...{ a }] = b

[...a, b] = c

func(...a, b)

({ t(eval) { "use strict"; } });

"use strict"; `${test}\02`;

[...a, ] = b

if (b,...a, );

(b, ...a)

module "Universe" { ;  ;  

switch (cond) { case 10: let a = 20; 

"use strict"; (eval) => 42

(eval) => { "use strict"; 42 }

({ get test() { } }) => 42