OpenLLM-France/wikimedia huggingface dataset:
# Super Mario 64/Big Boo's Haunt

Boo! Some ghosts are haunting out the courtyard - let's show them how scared we really are of some Big Boo's Haunt!
Location: Outside in the courtyard. Find the stairs going to the basement and follow the hallway across from them. Kill the lone ghost on the left of the courtyard, and hop in to the cage.
Description: Big mansion filled with ghosts.

## Original stars
### Star 1: Go On a Ghost Hunt

Kill all the little boos, and a big boo will appear in the main room. Kill him for a star.

### Star 2: Ride Big Boo's Merry-go-round

In the spinning wheel at the bottom of the outside house, kill Little Boos until a Big Boo appears, then kill the Big Boo.

### Star 3: Secret Of The Haunted Books

Go upstairs and you will see a room where books fly across at you. At the end of the hallway, there are three books sticking out of the shelf. Hit them in this order: Top, Right, Left. The book shelf will open revealing the door to a star.

### Star 4: Seek The 8 Red Coins

Get all 8 red coins. Look all inside the house. Be sure to go upstairs and downstairs.

### Star 5: Big Boos Balcony

Go to the second floor and go through the door on the right. If you look around in this room, you will see a second balcony. Wall kick up there. If you go out the door to the balcony, there will be another big boo. Ground pound him three times, then long jump across and climb the roof to get to the star

### Star 6: Eye To Eye In The Secret Room

Get to the balcony where the blue cap box is, and get it. Go up to the room where the door to big boo's balcony is, and go through the picture of the ghost. Run around the eyeball for the star.

### Star 7: 100 Coins

Collect 100 coins in total from the ghosts, the munching books, the eyeballs (run around them), and the blue coin box. There are 21 blue coins in this level. The coins do not have to be blue.
# Super Mario 64/Bowser in the Fire Sea

To enter the Fire Sea, you must have 30 stars and have beaten Bowser in the Dark World to get the key to the basement. When you go through the Star Door in the basement for the first time, the entrance to Dire, Dire Docks will be blocking the entrance to the Fire Sea. Beat the first level of Dire, Dire Docks to make it uncover the entrance to the Fire Sea.

## Normal route (no red coins)

Mario will drop into the Fire Sea, but there will be no message from Bowser on this level. Begin by running up to the platform in front of you and stay on it as it moves through the lava. Avoid the wall in your way, then jump onto the two platforms to the left side to you won't get burned when the moving platform goes under the lava. Jump back onto the platform and ride it to the end. Jump onto the blue platforms above the lava and jump to the next gray one (be careful on the blue platforms, as the lava moves on and off them slowly). Avoid the bully and the Goombas and run to the end where a moving pole is sticking out of the lava. Avoid the electric sphere and jump onto the pole, then jump onto the platform above. Turn around and jump onto the tilting gray platforms, and then jump onto the pole at the end of the second one. Climb up the pole and jump off, and then walk over to the gray elevator to get up to the second level of the stage.
Once on the second level, run straight and long jump over the gap (be careful of the machine spitting fire in between). Run over the blue triangle, and then position yourself under the platform with the coins under it, and then jump and hold onto the bottom of it with A. Still holding A, climb over to the other side. Cross the moving platforms and avoid the two bullies ahead. Walk up the series of moving ramps and platforms to get to another gray platform. Run up the platform and jump over the series of blue platforms in the lava (avoid the fire-spitting things and the moving lava). Jump onto the platform with the spinning heart and then jump onto the moving pole. Jump up to the next platform and keep jumping onto moving poles and platforms until you reach the gray platform with the bridge in front of it. Run across the bridge quickly (it falls apart as you do) and jump into the large pipe with an image of a star in it to reach Bowser.

## Red Coin Route

Under construction

## Defeating Bowser

To defeat Bowser, do the same thing as you did with the last one; grab his tail and throw him into a bomb. Be careful this time though, as Bowser tends to jump and pound the platform, which causes it to tilt. Run to the other side to avoid falling off. Also, Bowser can teleport around the platform, so keep an eye out for that.
# Super Mario 64/Cavern of the Metal Cap

Location: In level 6. Go to the underground lake, and ride the blue sea beast to the door across from where you came in. The metal cap course is in the pool inside.
Description: Long level with a strong current. Don't get sucked in to the waterfall; you'll end up outside.
# Super Mario 64/Characters

Throughout the game, Mario will encounter various characters which may damage his health to various severities, but can also have utilities.

## Goomba

Gives Mario one unit of damage when bumped, and one yellow coin when stomped.
In Tiny-Huge-Island, they appear as tiny and huge variants respectively, where the tiny causes no damage and disappears without coin when bumped, and one yellow coin when stomped. The huge causes two units of damage when bumped, and one blue coin when stomped. The sound when stumping noticably differs from ordinary goombas.

## Bob-omb

Causes no damage when touched, but two units of damage when exploding. Can be picked up and thrown.

## Pink Bob-omb

They do not explode. Pressing "B" near them causes them to unlock a cannon. An additional one in Bob-omb battlefield tells a story about rivalry with the normal (grey) Bob-ombs.

## Koopa

Causes no damage when bumped, gives a blue coin (worth five coins) and a Koopa shell when stomped. The shell can be used to surf on water and lava, and allows riding up slippery slopes uphill.
A stompable Koopa is found in Bob-omb Battlefield. In some courses, such as Jolly-Roger Bay and Shifting Sand Land, Koopa shells are located in breakable boxes.

## Owl

Elevates Marios altitude and provides a birds-eye view of the course. Found in Tall Tall Mountain, Whomp's Fortress, and Snowman's Land.

## Fly-guy

Spits fire, which causes three units of damage. Bumping causes two units of damage. Stomping causes Mario to spin, which allows him to glide for long distances through the air. Found in Tall Tall Mountain and Snowman's Land.

## Thwomp

Quader brick which tries to throws itself on Mario. Causes three units of damage if it flattens Mario. Needs to be stomped using ground pound. Found in Thromp's Fortress and Bowser in the Sky.

## Chuckya

Grabs and throws Mario. Dangerous because located near tall slopes and high platforms such as in Rainbow Ride, Wet-Dry World, Bowser in the Sky, and Tall-Tall Mountain. Can be destroyed by being picked up and thrown by Mario.

## Toad

Located throughout the castle. Engaging by pressing "A" makes them tell a story and/or praise Mario. Three of them provide a star, one located in the basement near the entry to "Hazy Maze Cave", one in the upper hallway, and another one in the dark_cyan-walled star room near the top of the castle.
# Structural Biochemistry/Membrane Proteins/Folding
## Membrane Protein Folding

The study of membrane protein folding has been complicated by several factors. Historically, membrane proteins have been very difficult to crystallize due to their large amounts of hydrophobic residues. Proteins that reside in these biological membranes have different surface properties than water-soluble proteins. The proteins are more so affected by the lateral forces and elastic forces from being within the membrane. Duplicating these conditions in order to observe a membrane protein in vitro has been difficult due to the fact that once the membrane protein has been separated, it either unfolds or no longer stays functional.

### Approaches to Study Membrane Proteins
#### Manipulating Lipid Bilayer

Maniuplating the lipid bilayer to observe proteins has been increasingly successful. Studies used on smaller water-soluble proteins are very effective with this method. The combination of kinetic and thermodynamic studies of the small water-soluble proteins have been feasible to observe the helical proteins which contain a lot of alpha helices.

## Consequences of incorrect protein folding

Incorrectly folded proteins are associated with prion-related illnesses such as Creutzfeldt-Jakob disease, bovine spongiform encephalopathy (mad cow disease), amyloid-related illnesses such as Alzheimer's disease and familial amyloid cardiomyopathy or polyneuropathy, as well as intracytoplasmic aggregation diseases such as Huntington's and Parkinson's disease. These age onset degenerative diseases are associated with the aggregation of misfolded proteins into insoluble, extracellular aggregates and/or intracellular inclusions including cross-beta sheet amyloid fibrils. While it is not completely clear whether the aggregates are the cause or merely a reflection of the loss of protein homeostasis, the balance between synthesis, folding, aggregation and protein turnover, the recent European Medicines Agency approval of Tafamidis or Vyndaqel (a kinetic stabilizer of tetrameric transthyretin) for the treatment of the transthyretin amyloid diseases suggests that it is the process of amyloid fibril formation and not the fibrils themselves that causes the degeneration of post-mitotic tissue in human amyloid diseases.[18] Misfolding and excessive degradation instead of folding and function leads to a number of proteopathy diseases such as antitrypsin-associated emphysema, cystic fibrosis and the lysosomal storage diseases, where loss of function is the origin of the disorder. While protein replacement therapy has historically been used to correct the latter disorders, an emerging approach is to use pharmaceutical chaperones to fold mutated proteins to render them functional.
# Structural Biochemistry/Membrane Proteins/Active Transport/Sodium-Potassium Pumps

when the concentration of potassium is really high and concentration of the sodium is really low.This Pump is called the sodium potassium ATPase because hydrolysis of ATP only takes place when sodium and potassium are present. the sodium potassium gradient in animal cells controls volume, renders neurons and muscle cells electrically excitable. ATPase requires MG+2 9(just like any other enzyme). we can calculated the change in free energy that accur with the transport of sodium and potassium.
# ROSE Compiler Framework/Plugin
## Overview

Starting from Version 0.9.9.83, ROSE has a new feature to support external plugins. It borrows the design and implementation of Clang Plugins.
The process to isolate the relevant source files and headers in Clang is available at:
* https://github.com/chunhualiao/Clang-Plugin-Extracted
The interface is very similar to what Clang has, with some simplification and improvements.
With this feature, you can develop your ROSE-based tools as dynamically loadable plugins. Then you can use command line options of ROSE's default translator, rose-compiler (or another ROSE translator), to
* load shared libraries containing the plugins,
* specify actions to be executed,
* as well as pass command line options to each action.

## Benefits

The main benefit of using plugins is that you can use a single installed ROSE default translator to execute one or more arbitrary external plugins, in the order they appear on the command line.
This will significantly reduce the overhead of composing ROSE-based transformations, by reusing the costly parsing and unparsing, and freely chaining up the transformation plugins through command line options.
The deployment of plugins are much simpler also. No need to recompile/reinstall ROSE.
For example, we had to call two heavy-weight tools in two command lines:
Now, we can call the default ROSE rose-compiler and chain up two plugins (act1 and act2) instead:

## Command Line Interface

rose-compiler --help , excerpt of the plugin section
Examples
* rose-compiler -rose:plugin_lib /path/libPrintNamesPlugin.so -rose:plugin_action print-names -rose:plugin_arg_print-names pretty-printing
** load a shared library containing a single plugin, execute the plugin named print-names, also pass an option named "pretty-printing" to the plugin.
* rose-compiler -rose:plugin_lib lib.so -rose:plugin_lib lib2.so -rose:plugin_action act1 -rose:plugin_action act2 -rose:plugin_arg_act1 op1 -rose:plugin_arg_act1 op2 -rose:plugin_arg_act2 op3 -rose:plugin_arg_act2 op4
** load multiple shared libraries, executing two actions in the order they show up in the command line, also pass multiple options to each of the plugins

## Plugin Super Class

Two interface functions are provided for a ROSE plugin:
* ParseArgs: optionally handle command line options passed to this plugin
* process: process the AST

## An Example Plugin

You can find the full example from
* https://github.com/rose-compiler/rose-plugin
This plugin will just print all defining functions' names of an input source file.

### Compile the plugin

A sample makefile
* Note: copy&paste may not work since tabs will be wrongfully pasted as whitespaces. You need to restore tabs before commands in the Makefile.

### Running the plugin

Command line and options:
* rose-compiler -rose:plugin_lib PrintNamesPlugin.so -rose:plugin_action print-names -rose:plugin_arg_print-names op1 -c input_testPlugins.C
Sample input file: input_testPlugins.C
Sample output:
# ROSE Compiler Framework/Processing Pragmas
## overview

It is often useful to use pragmas to guide a translator.
A set of parser building functions are provided to help create recursive descent parsers:
* http://rosecompiler.org/ROSE_HTML_Reference/namespaceAstFromString.html
Once you include the header AstFromString.h (located in src/frontend/SageIII/astFromString), you can access the variables and functions defined in the namespace.
There is an example project doing pragma parsing and saving the results into AST attributes. https://github.com/rose-compiler/rose-develop/tree/master/projects/pragmaParsing

## Parsing recursive rules

left recursion
recursion rules are converted into repetition rules:
# DESCRIPTION:

Saves a value or a block to a file or url.
SAVE is a native value.

# ARGUMENTS

* where -- Where to save it. (Type: file url binary)
* value -- Value to save. (Type: any)

# REFINEMENTS

* /header -- Save it with a header
** header-data -- Header block or object (Type: block object)
* /bmp -- Save in .BMP format
* /png -- Save in .PNG format
* /all -- Save in serialized format
# DESCRIPTION:

Returns the absolute screen offset for any face.
SCREEN-OFFSET? is a function value.

# ARGUMENTS

* face -- (Type: object)
# DESCRIPTION:

Save user.r, prompting for overwrite permission
SAVE-USER is a function value.
# DESCRIPTION:

Runs the system application associated with a file.
RUN is a native value.

# ARGUMENTS

* file -- The file to open (file, URL) or command to run (string). (Type: file url string)

# REFINEMENTS

* /as
** suffix -- (Type: string file)
# DESCRIPTION:

Returns TRUE if the values are identical.
SAME? is an action value.

# ARGUMENTS

* value1 -- (Type: any)
* value2 -- (Type: any)
# Rebol Programming/save-prefs

SAVE-PREFS is a none of value: none
# DESCRIPTION:

Checks file, url, or string for a valid script header.
SCRIPT? is a native value.

# ARGUMENTS

* value -- (Type: file url string)
# DESCRIPTION:

Return TRUE if value is any type of scalar.
SCALAR? is a function value.

# ARGUMENTS

* value -- (Type: any-type)
# DESCRIPTION:

Move the scroller drag bar
SCROLL-DRAG is a function value.

# ARGUMENTS

* face -- the scroller to modify (Type: any)

# REFINEMENTS

* /back -- move backward
* /page -- move each time by one page
# Ring/Lessons/Embedding Ring Interpreter in C/C++ Programs
## Embedding Ring Interpreter in C/C++ Programs

We can call the Ring interpreter from C/C++ programs using the next functions

## Ring State

The idea is to use the ring_state_init to create new state for the Ring Interpreter then call the ring_state_runcode function to execut Ring code using the same state. When we are done, we call the ring_state_delete to free the memory.
Example:
Output:

## Ring State Functions

The Ring API comes with the next functions to create and delete the state. Also we have functions to create new variables and get variables values.

## Ring State Variables

We can create more than one ring state in the same program and we can create and modify variable values.
To get the variable list we can use the ring_state_findvar function.
To create new variable we can use the ring_state_newvar function.
Example:
Output:
# Ring/Lessons/Functions
## Functions

In this chapter we are going to learn about the next topics :-
* Define functions
* Call functions
* Declare parameters
* Send parameters
* Main Function
* Variables Scope
* Program structure
* Return Value
* Recursion

## Define Functions

To define new function
Syntax:
.. note:: No keyword is required to end the function definition.
Example:

## Call Functions

To call function without parameters, we type the function name then
.. tip:: We can call the function before the function definition and the function code.
Example:
Example:

## Declare parameters

To declare the function parameters, after the function name type the list of parameters as a group of identifiers separated by comma.
Example:

## Send Parameters

To send parameters to function, type the parameters inside after the function name
Syntax:
Example:

## Main Function

Using the Ring programming language, the Main Function is optional, when it's defined, it will be executed after the end of other statements.
if no other statements comes alone, the main function will be the first `entry point <http://en.wikipedia.org/wiki/Entry_point>`_
Example:

## Variables Scope

The Ring programming language uses `lexical scoping <http://en.wikipedia.org/wiki/Scope_%28computer_science%29#Lexical_scope_vs._dynamic_scope>`_ to determine the scope of a variable.
Variables defined inside functions (including function parameters) are local variables. Variables defined outside functions (before any function) are global variables.
Inside any function we can access the variables defined inside this function beside the global variables.
Example:
.. note:: Using the main function before the for loop declare the t variable as a local variable, It's recommended to use the main functions instead of typing the instructions directly to set the scope of the new variables to local.

## Program Structure

The application maybe one or more of files.
to include another source file in the project, just use the load command.
Syntax:
Example:

## Return Value

The function can return a value using the Return command.
Syntax:
.. tip:: the Expression after the return command is optional and we can use the return command to end the function execution without returning any value.
.. note:: if the function doesn't return explicit value, it will return NULL (empty string = "" ).
Example:

## Recursion

The Ring programming language support `Recursion <http://en.wikipedia.org/wiki/Recursion_%28computer_science%29>`_ and the function can call itself using different parameters.
Example:
# Ring/Lessons/Getting Input
## Getting Input

We can get input from the keyboard using
* The Give Command
* The GetChar Function
* The Input Function

## Give Command

Syntax:
Example:
Output:

## GetChar Function

We can get one character from the standard input using the GetChar function
Syntax:
Example:

## Input Function

We can get input from the keyboard using the Input function
Syntax:
The function will wait until nCount characters (at least) are read
Example:
# Ring/Lessons/Demo Programs
## Demo Programs

In this chapter we will see simple demo programs
* Language Shell
* Main Menu

## Language Shell

We can create simple interactive programming environment using the next program
Output:

## Main Menu

Example:
Output:
# Ring/Lessons/Eval and Debugging
## Eval and Debugging

In this chapter we are going to learn about
* Error Handling using Try/Catch/Done
* Eval function
* Raise function
* Assert function

## Try/Catch/Done

Syntax:
The statements in the Try block will be executed, if any error happens then the statements in the catch block will be executed.
Inside the catch block we can use the variable cCatchError to get the error message
Example:
Output:

## Eval Function

We can execute code during the runtime from string using the Eval function
Syntax:
Example:
Output:

## Raise Function

We can raise an exception using the Raise function
Syntax:
The function will display the error message then end the execution of the program.
We can use Try/Catch/Done to avoid exceptions generated by raise function.
Example:
if nMode < 0 or nMode > 5 raise("Error : nMode not in the range 1:4") ok
Output:
Example:
Output:

## Assert Function

We can use the Assert function to test conditions before executing the code
If the test fail the program will be terminated with an error message contains the assert condition.
Syntax:
Example:
Output: