diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index 6a6df968..a1dfe9e1 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -155,7 +155,7 @@ Small-o, commonly written as **o**, is an Asymptotic Notation to denote the
upper bound (that is not asymptotically tight) on the growth rate of runtime
of an algorithm.
-`f(n)` is o(g(n)), if for some real constants c (c > 0) and n0 (n0 > 0), `f(n)` is < `c g(n)`
+`f(n)` is o(g(n)), if for all real constants c (c > 0) and n0 (n0 > 0), `f(n)` is < `c g(n)`
for every input size n (n > n0).
The definitions of O-notation and o-notation are similar. The main difference
@@ -168,7 +168,7 @@ Small-omega, commonly written as **ω**, is an Asymptotic Notation to denote
the lower bound (that is not asymptotically tight) on the growth rate of
runtime of an algorithm.
-`f(n)` is ω(g(n)), if for some real constants c (c > 0) and n0 (n0 > 0), `f(n)` is > `c g(n)`
+`f(n)` is ω(g(n)), if for all real constants c (c > 0) and n0 (n0 > 0), `f(n)` is > `c g(n)`
for every input size n (n > n0).
The definitions of Ω-notation and ω-notation are similar. The main difference
diff --git a/bash.html.markdown b/bash.html.markdown
index d1e6bf25..cb805da7 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -25,7 +25,7 @@ Nearly all examples below can be a part of a shell script or executed directly i
[Read more here.](http://www.gnu.org/software/bash/manual/bashref.html)
```bash
-#!/bin/bash
+#!/usr/bin/env bash
# First line of the script is shebang which tells the system how to execute
# the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
# As you already figured, comments start with #. Shebang is also a comment.
diff --git a/citron.html.markdown b/citron.html.markdown
new file mode 100644
index 00000000..bd3c398c
--- /dev/null
+++ b/citron.html.markdown
@@ -0,0 +1,212 @@
+---
+language: citron
+filename: learncitron.ctr
+contributors:
+ - ["AnotherTest", ""]
+lang: en-us
+---
+```ruby
+# Comments start with a '#'
+# All comments encompass a single line
+
+###########################################
+## 1. Primitive Data types and Operators
+###########################################
+
+# You have numbers
+3. # 3
+
+# Numbers are all doubles in interpreted mode
+
+# Mathematical operator precedence is not respected.
+# binary 'operators' are evaluated in ltr order
+1 + 1. # 2
+8 - 4. # 4
+10 + 2 * 3. # 36
+
+# Division is always floating division
+35 / 2 # 17.5.
+
+# Integer division is non-trivial, you may use floor
+(35 / 2) floor # 17.
+
+# Booleans are primitives
+True.
+False.
+
+# Boolean messages
+True not. # False
+False not. # True
+1 = 1. # True
+1 !=: 1. # False
+1 < 10. # True
+
+# Here, `not` is a unary message to the object `Boolean`
+# Messages are comparable to instance method calls
+# And they have three different forms:
+# 1. Unary messages: Length > 1, and they take no arguments:
+ False not.
+# 2. Binary Messages: Length = 1, and they take a single argument:
+ False & True.
+# 3. Keyword messages: must have at least one ':', they take as many arguments
+# as they have `:` s
+ False either: 1 or: 2. # 2
+
+# Strings
+'This is a string'.
+'There are no character types exposed to the user'.
+# "You cannot use double quotes for strings" <- Error
+
+# Strins can be summed
+'Hello, ' + 'World!'. # 'Hello, World!'
+
+# Strings allow access to their characters
+'This is a beautiful string' at: 0. # 'T'
+
+###########################################
+## intermission: Basic Assignment
+###########################################
+
+# You may assign values to the current scope:
+var name is value. # assignes `value` into `name`
+
+# You may also assign values into the current object's namespace
+my name is value. # assigns `value` into the current object's `name` property
+
+# Please note that these names are checked at compile (read parse if in interpreted mode) time
+# but you may treat them as dynamic assignments anyway
+
+###########################################
+## 2. Lists(Arrays?) and Tuples
+###########################################
+
+# Arrays are allowed to have multiple types
+Array new < 1 ; 2 ; 'string' ; Nil. # Array new < 1 ; 2 ; 'string' ; Nil
+
+# Tuples act like arrays, but are immutable.
+# Any shenanigans degrade them to arrays, however
+[1, 2, 'string']. # [1, 2, 'string']
+
+# They can interoperate with arrays
+[1, 'string'] + (Array new < 'wat'). # Array new < 1 ; 'string' ; 'wat'
+
+# Indexing into them
+[1, 2, 3] at: 1. # 2
+
+# Some array operations
+var arr is Array new < 1 ; 2 ; 3.
+
+arr head. # 1
+arr tail. # Array new < 2 ; 3.
+arr init. # Array new < 1 ; 2.
+arr last. # 3
+arr push: 4. # Array new < 1 ; 2 ; 3 ; 4.
+arr pop. # 4
+arr pop: 1. # 2, `arr` is rebound to Array new < 1 ; 3.
+
+# List comprehensions
+[x * 2 + y,, arr, arr + [4, 5],, x > 1]. # Array ← 7 ; 9 ; 10 ; 11
+# fresh variable names are bound as they are encountered,
+# so `x` is bound to the values in `arr`
+# and `y` is bound to the values in `arr + [4, 5]`
+#
+# The general format is: [expr,, bindings*,, predicates*]
+
+
+####################################
+## 3. Functions
+####################################
+
+# A simple function that takes two variables
+var add is {:a:b ^a + b.}.
+
+# this function will resolve all its names except the formal arguments
+# in the context it is called in.
+
+# Using the function
+add applyTo: 3 and: 5. # 8
+add applyAll: [3, 5]. # 8
+
+# Also a (customizable -- more on this later) pseudo-operator allows for a shorthand
+# of function calls
+# By default it is REF[args]
+
+add[3, 5]. # 8
+
+# To customize this behaviour, you may simply use a compiler pragma:
+#:callShorthand ()
+
+# And then you may use the specified operator.
+# Note that the allowed 'operator' can only be made of any of these: []{}()
+# And you may mix-and-match (why would anyone do that?)
+
+add(3, 5). # 8
+
+# You may also use functions as operators in the following way:
+
+3 `add` 5. # 8
+# This call binds as such: add[(3), 5]
+# because the default fixity is left, and the default precedance is 1
+
+# You may change the precedence/fixity of this operator with a pragma
+#:declare infixr 1 add
+
+3 `add` 5. # 8
+# now this binds as such: add[3, (5)].
+
+# There is another form of functions too
+# So far, the functions were resolved in a dynamic fashion
+# But a lexically scoped block is also possible
+var sillyAdd is {\:x:y add[x,y].}.
+
+# In these blocks, you are not allowed to declare new variables
+# Except with the use of Object::'letEqual:in:`
+# And the last expression is implicitly returned.
+
+# You may also use a shorthand for lambda expressions
+var mul is \:x:y x * y.
+
+# These capture the named bindings that are not present in their
+# formal parameters, and retain them. (by ref)
+
+###########################################
+## 5. Control Flow
+###########################################
+
+# inline conditional-expressions
+var citron is 1 = 1 either: 'awesome' or: 'awful'. # citron is 'awesome'
+
+# multiple lines is fine too
+var citron is 1 = 1
+ either: 'awesome'
+ or: 'awful'.
+
+# looping
+10 times: {:x
+ Pen writeln: x.
+}. # 10. -- side effect: 10 lines in stdout, with numbers 0 through 9 in them
+
+# Citron properly supports tail-call recursion in lexically scoped blocks
+# So use those to your heart's desire
+
+# mapping most data structures is as simple as `fmap:`
+[1, 2, 3, 4] fmap: \:x x + 1. # [2, 3, 4, 5]
+
+# You can use `foldl:accumulator:` to fold a list/tuple
+[1, 2, 3, 4] foldl: (\:acc:x acc * 2 + x) accumulator: 4. # 90
+
+# That expression is the same as
+(2 * (2 * (2 * (2 * 4 + 1) + 2) + 3) + 4)
+
+###################################
+## 6. IO
+###################################
+
+# IO is quite simple
+# With `Pen` being used for console output
+# and Program::'input' and Program::'waitForInput' being used for console input
+
+Pen writeln: 'Hello, ocean!' # prints 'Hello, ocean!\n' to the terminal
+
+Pen writeln: Program waitForInput. # reads a line and prints it back
+```
diff --git a/common-lisp.html.markdown b/common-lisp.html.markdown
index e2cf62fb..76e7735b 100644
--- a/common-lisp.html.markdown
+++ b/common-lisp.html.markdown
@@ -16,7 +16,7 @@ popular and recent book is [Land of Lisp](http://landoflisp.com/). A new book ab
-```common-lisp
+```lisp
;;;-----------------------------------------------------------------------------
;;; 0. Syntax
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 568e4343..35becf94 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -13,7 +13,7 @@ Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce či
a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
dalších formátů)
-```markdown
+```md
diff --git a/markdown.html.markdown b/markdown.html.markdown
index ece2567c..cf4286e2 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -197,7 +197,7 @@ inside your code
end
```
-Inline code can be created using the backtick character `
+Inline code can be created using the backtick character `` ` ``
```md
John didn't even know what the `go_to()` function did!
diff --git a/mips.html.markdown b/mips.html.markdown
new file mode 100644
index 00000000..1133f769
--- /dev/null
+++ b/mips.html.markdown
@@ -0,0 +1,366 @@
+---
+language: "MIPS Assembly"
+filename: MIPS.asm
+contributors:
+ - ["Stanley Lim", "https://github.com/Spiderpig86"]
+---
+
+The MIPS (Microprocessor without Interlocked Pipeline Stages) Assembly language
+is designed to work with the MIPS microprocessor paradigm designed by J. L.
+Hennessy in 1981. These RISC processors are used in embedded systems such as
+gateways and routers.
+
+[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```assembly
+# Comments are denoted with a '#'
+
+# Everything that occurs after a '#' will be ignored by the assembler's lexer.
+
+# Programs typically contain a .data and .text sections
+
+.data # Section where data is stored in memory (allocated in RAM), similar to
+ # variables in higher level languages
+
+ # Declarations follow a ( label: .type value(s) ) form of declaration
+ hello_world: .asciiz "Hello World\n" # Declare a null terminated string
+ num1: .word 42 # Integers are referred to as words
+ # (32 bit value)
+
+ arr1: .word 1, 2, 3, 4, 5 # Array of words
+ arr2: .byte 'a', 'b' # Array of chars (1 byte each)
+ buffer: .space 60 # Allocates space in the RAM
+ # (not cleared to 0)
+
+ # Datatype sizes
+ _byte: .byte 'a' # 1 byte
+ _halfword: .half 53 # 2 bytes
+ _word: .word 3 # 4 bytes
+ _float: .float 3.14 # 4 bytes
+ _double: .double 7.0 # 8 bytes
+
+ .align 2 # Memory alignment of data, where
+ # number indicates byte alignment in
+ # powers of 2. (.align 2 represents
+ # word alignment since 2^2 = 4 bytes)
+
+.text # Section that contains instructions
+ # and program logic
+.globl _main # Declares an instruction label as
+ # global, making it accessible to
+ # other files
+
+ _main: # MIPS programs execute instructions
+ # sequentially, where the code under
+ # this label will be executed firsts
+
+ # Let's print "hello world"
+ la $a0, hello_world # Load address of string stored in
+ # memory
+ li $v0, 4 # Load the syscall value (indicating
+ # type of functionality)
+ syscall # Perform the specified syscall with
+ # the given argument ($a0)
+
+ # Registers (used to hold data during program execution)
+ # $t0 - $t9 # Temporary registers used for
+ # intermediate calculations inside
+ # subroutines (not saved across
+ # function calls)
+
+ # $s0 - $s7 # Saved registers where values are
+ # saved across subroutine calls.
+ # Typically saved in stack
+
+ # $a0 - $a3 # Argument registers for passing in
+ # arguments for subroutines
+ # $v0 - $v1 # Return registers for returning
+ # values to caller function
+
+ # Types of load/store instructions
+ la $t0, label # Copy the address of a value in
+ # memory specified by the label into
+ # register $t0
+ lw $t0, label # Copy a word value from memory
+ lw $t1, 4($s0) # Copy a word value from an address
+ # stored in a register with an offset
+ # of 4 bytes (addr + 4)
+ lb $t2, label # Copy a byte value to the lower order
+ # portion of the register $t2
+ lb $t2, 0($s0) # Copy a byte value from the source
+ # address in $s0 with offset 0
+ # Same idea with 'lh' for halfwords
+
+ sw $t0, label # Store word value into memory address
+ # mapped by label
+ sw $t0, 8($s0) # Store word value into address
+ # specified in $s0 and offset of 8 bytes
+ # Same idea using 'sb' and 'sh' for bytes and halfwords. 'sa' does not exist
+
+### Math ###
+ _math:
+ # Remember to load your values into a register
+ lw $t0, num # From the data section
+ li $t0, 5 # Or from an immediate (constant)
+ li $t1, 6
+ add $t2, $t0, $t1 # $t2 = $t0 + $t1
+ sub $t2, $t0, $t1 # $t2 = $t0 - $t1
+ mul $t2, $t0, $t1 # $t2 = $t0 * $t1
+ div $t2, $t0, $t1 # $t2 = $t0 / $t1 (Might not be
+ # supported in some versons of MARS)
+ div $t0, $t1 # Performs $t0 / $t1. Get the quotient
+ # using 'mflo' and remainder using 'mfhi'
+
+ # Bitwise Shifting
+ sll $t0, $t0, 2 # Bitwise shift to the left with
+ # immediate (constant value) of 2
+ sllv $t0, $t1, $t2 # Shift left by a variable amount in
+ # register
+ srl $t0, $t0, 5 # Bitwise shift to the right (does
+ # not sign preserve, sign-extends with 0)
+ srlv $t0, $t1, $t2 # Shift right by a variable amount in
+ # a register
+ sra $t0, $t0, 7 # Bitwise arithmetic shift to the right
+ # (preserves sign)
+ srav $t0, $t1, $t2 # Shift right by a variable amount
+ # in a register
+
+ # Bitwise operators
+ and $t0, $t1, $t2 # Bitwise AND
+ andi $t0, $t1, 0xFFF # Bitwise AND with immediate
+ or $t0, $t1, $t2 # Bitwise OR
+ ori $t0, $t1, 0xFFF # Bitwise OR with immediate
+ xor $t0, $t1, $t2 # Bitwise XOR
+ xori $t0, $t1, 0xFFF # Bitwise XOR with immediate
+ nor $t0, $t1, $t2 # Bitwise NOR
+
+## BRANCHING ##
+ _branching:
+ # The basic format of these branching instructions typically follow
+ #