OpenLLM-France/wikimedia huggingface dataset:
# MapleStory/Towns/El Nath

* MapleStory
* Complete Table of Contents
* Jobs
* Locations
* Shops
* Monsters
* Quests
* FAQs
* Glossary
* Authors list
* Training Location Guide
* Maple Island
* Amherst
* Southperry
* Victoria Island
* Lith Harbor
* Ellinia
* Henesys
* Kerning City
* Perion
* Sleepywood
* Ossyria
* Orbis
* El Nath
* Aquarium
* Ludibrium
* Omega Sector
El Nath is a snowy town that can be accessed via the first floor of Orbis Tower. Past El Nath is the volcano-like Dungeon area, which can only be accessed if one is level 50 or above.
One begins to see El Nath starting at the 5th floor or Orbis Tower or so, where the floor becomes snowy. Upon exiting the first floor, the player's HP immediately begins to decrease by 10 every 5 seconds. This is a unique feature of El Nath. On every map outside of the main city, players lose HP every 5 seconds as a result of the extreme cold. This can be remedied using Red Bean Soups available in the El Nath potion shop.
Due to the snow, travelling around El Nath can be fun, as players slide around. By wearing Snowshoes available in El Nath, players will not slide around but instead walk normally, as in all other towns (except perhaps Aquarium).
Travelling right, players come across the El Nath fields, which include Jr. Yetis, their senior and dark forms, Pepes, and many other monsters. At the top of a certain map, players reach a dead end unless they are level 50 or above. There is a potion seller at this map.
Once inside the level 50 area, players encounter much more difficult monsters such as Werewolves and Lycanthropes. Zombies, a popular training area, can be found here. Deeper within the level 50 area is the Dungeon, featuring some of the most difficult monsters in the game such as Cerebes and Bains. At the end of the Dungeon is the Zakum Party Quest area. After completing the Zakum Party Quest, players may face Zakum, (arguably) the toughest monster in the game except for jms, which is the yakuza
# MapleStory/Towns/Ellinia

* MapleStory
* Complete Table of Contents
* Jobs
* Locations
* Shops
* Monsters
* Quests
* FAQs
* Glossary
* Authors list
* Training Location Guide
* Maple Island
* Amherst
* Southperry
* Victoria Island
* Lith Harbor
* Ellinia
* Henesys
* Kerning City
* Perion
* Sleepywood
* Ossyria
* Orbis
* El Nath
* Aquarium
* Ludibrium
* Omega Sector

## Etran: Gloves

| Item | Price |
| Lemona | 15 Leathers 7000 Mesos |
| Blue Morrican | 30 Leathers 1 Steel 15000 Mesos |
| Ocean Mesana | 50 Leathers 2 Golds 20000 Mesos |
| Red Lutia | 60 Leathers 1 Topaz 2 Garnets 25000 Mesos |
| Red Noel | 70 Leathers 1 Gold 3 Steels 2 Garnets 30000 Mesos |
| Red Arten | 80 Leathers 3 Garnets 3 Topazzes 30 Screws 40000 Mesos |
| Red Pennance | 3 Garnets 2 Golds 35 Dragon Skins 40 Screws 50000 Mesos |
| Steel Manute | 1 Moon Rock 8 Steels 1 Diamond 50 Dragon Skins 50 Screws 70000 Mesos |
# MapleStory/Towns/Kerning City

* MapleStory
* Complete Table of Contents
* Jobs
* Locations
* Shops
* Monsters
* Quests
* FAQs
* Glossary
* Authors list
* Training Location Guide
* Maple Island
* Amherst
* Southperry
* Victoria Island
* Lith Harbor
* Ellinia
* Henesys
* Kerning City
* Perion
* Sleepywood
* Ossyria
* Orbis
* El Nath
* Aquarium
* Ludibrium
* Omega Sector
This is the place where you become a thief. You must be at least level 10 and have 25 dex. This is the most urban-like town in Victoria Island, hence, its name.
# Introduction

The Universal Serial Bus protocol is used to connect many different devices to a computer, such as keyboards, mice, CD readers, video cameras and audio ports.

# Hardware view

The Mizar32 has a micro OTG (On-The-Go) USB socket which can act as a USB device to be seen by an external computer, or as a USB master to talk with USB devices.

# Software view

You can't program the USB subsystem directly from Alcor6L. Instead, it contains software that pretends to be a USB serial port which is connected to the Alcor6L console in the SimpleMachines firmware releases from 2013 onwards (before that, the console was connected to a real serial port on the Mizar32 RS232 UART add-on hardware module.)
On a GNU/Linux PC, you can use the minicom terminal to talk to Alcor6L's USB serial port, specifying the serial device as /dev/ttyACM0. When it's talking to a GNU/Linux-based operating system it takes about 8 seconds for the Mizar32 and the PC to start talking to one another after you power the Mizar32 on.
On Windows it should appear as a USB serial device when you plug it in and you can use the PuTTY terminal emulator to talk to it but the whole system hangs if you reset or power-cycle the Mizar32. To get the Mizar32 and Windows talking to each other again, a Windows user writes:
You can compile custom firmware at http://builder.simplemachines.it placing the console on a real serial port or on telnet, leaving the USB system free from interference from console output. In this case it can be used like any other serial port by passing serial port number 176 to eLua's uart.* functions.

# As used by the DFU boot loader

When the Device Firmware Upgrade Boot Loader software is activated, it also uses the USB port to talk to your PC, but not as a USB serial port. Instead, it emulates a special Atmel device which speaks the DFU firmware-updating language and requires special software on the attached PC, such as dfu-programmer or batchisp3. See the Advanced Topic on flashing firmware to the Mizar32 with the DFU bootloader.
# Mizar32 software

Two pieces of software are factory-programmed into the Mizar32's flash memory:
* The tiny (8KB) USB DFU bootloader
* The Alcor6L system

## The DFU bootloader

When the Mizar32 powers on or when its Reset button is pressed, the DFU bootloader is the first program that it runs. This checks if the user button is pressed and, if it is, allows you to update the rest of the firmware from your PC.
If it isn't, it runs:

## The Alcor6L system

Alcor6L is a software system for natively programming microcontrollers (interactively and incrementally) using any of the following languages:
* Lua (using eLua)
* C (using PicoC)
* LISP (using PicoLisp and TinyScheme)
* BASIC (using MY-BASIC)
The Alcor6L system on your Mizar32 reads commands in any of the above languages from the SD card or from the console.
Alcor6L is a fork of the eLua project. It implements:
* Lua 5.1 as per the Lua 5.1 Reference Manual
* Integer variables and arithmetic instead of the usual double precision floating point for Lua
* Code to run the Lua compiler on the Mizar32
* Support for
** FAT filesystem on MMC/SD card
** console on the RS232 serial port or on USB serial port
** iv, a vi clone (running natively on Mizar32) for editing text files
* Standard Lua modules: coroutine, io, package, string, table
* Integer version of the math module with: abs, ceil, floor, huge, max, min, pow, random, randomseed, sqrt.
* Hardware driver modules: adc, i2c, pio, pwm, spi, tmr, uart
* Extension modules: bit, cpu, elua, pack, pd, term
* TCP/IP Networking uIP module: net
* Extension modules for the Mizar32 to drive the LCD character display and the Real Time Clock.
If you have the Mizar32 A or B models with 256KB or 512KB of flash, you can change the firmware to use floating point instead of integer variables. If you have a 128KB flash Mizar32 C and you need to load a bigger eLua image than will fit you can still do it by loading the image from SDCard to SDRAM and executing it in SDRAM (with a speed penalty) using the emBLOD second-stage bootloader.

## Further reading

* The PicoLisp documentation.
* The Lua 5.1 Reference Manual.
* There is a free online book teaching Lua 5.0 which has a second edition for Lua 5.1 available on paper.
* Pieces of Lua code to achieve some common effects can be found at snippets.luacode.org and more resources at lua-users.org.
* To write the fastest Lua code, consult the wiki of speed optimization tips.
# Mizar32/TODO

A list of TODOs:
* Mizar32/USB: Add pictures of USB plugs and sockets
* Documentation for PicoC view on Mizar32
* Add information for the new ks0108b glcd module
# Mizar Commentary on Walter Rudin's Principles of Mathematical Analysis
## Table of Contents

* Preface
* The Real and Complex Number Systems
* Basis Topology
* Numerical Sequences and Series
* Continuity
* Differentiation
* The Riemann-Stieltjes Integral
* Sequences and Series of Functions
* Some Special Functions
* Functions of Several Variables
* Integration of Differential Forms
* The Lebesgue Theory
* Bibliography
# Overview

Normally, the boot sequence is:
* the USB DFU bootloader at 0x8000000-80001FFF (8KB), which checks if the user button is pressed and, if it isn't, runs:
* the eLua interpreter at 0x80002000
emBLOD is an embedded boot loader that replaces eLua at 0x80002000 and loads a modified version of the eLua interpreter code from a file on a FAT-formatted SD card into the start of the 32MB SDRAM then executes it there. It is fast to start up (a fraction of a second) and gets round the 120KB code size limit of the Mizar32 model C.
The downside is that when loaded into SDRAM instead of Flash, the eLua interpreter runs at one sixth of the speed. However, if you need floating point or ethernet support on a Mizar32 model C, this is the only way to do it.

# Compiling emBLOD from source

emBLOD is an open source code project hosted at http://github.com/cmp1084/emBLOD
To fetch and build the source on Ubuntu you will need to install:
and the avr32 GCC cross-compiler, for which instructions are at the start of the compiling Alcor6L page.
The boot loader can be built from source as follows:
which creates two versions of the same object file: emblod.elf and bin/emblod.bin. However, dfu-programmer requires a .hex file, so convert it:
then connect the Mizar32 to your PC over USB, reset or power-on the board while holding SW2 depressed and issue these commands on the PC:
If you have the serial port connected at 115200-8-N-1, you will see messages issued by emBLOD.

# Compiling Alcor6L for emBLOD

You should already be familiar with compiling Alcor6L.
Use eLua 0.9, add
to the scons compilation command. This will create an ELF file, which you should convert to a BIN file using
and copy autorun.bin to the root of a FAT-formatted micro SD card for the Mizar32.
# Requiring or Prohibiting Heap-based Objects
### Intent

* Require or prevent creation of objects on heap

### Motivation

C++ supports different ways to create objects: stack-based (including temporary objects), heap-based, and objects of static storage duration (e.g., global objects, namespace-scope objects). Sometimes it is useful to limit the ways in which objects of a class can be created. For instance, a framework may require users to create only heap-based objects so that it can take control of the lifetime of objects regardless of the function that created them. Similarly, it may be useful to prohibit creation of objects on the heap. C++ has idiomatic ways to achieve this.

### Solution and Sample Code

Requiring heap-based objects
In this case, programmers must use new to create the objects and prohibit stack-based and objects of static duration. The idea is to prevent access to one of the functions that are always needed for stack-based objects: constructors or destructors. Preventing access to constructors, i.e., protected/private constructors will prevent heap-based objects too. Therefore, the only available way is to create a protected destructor as below. Note that a protected destructor will also prevent global and namespace-scope objects because eventually the objects are destroyed but the destructor is inaccessible. The same is applicable to temporary objects because destroying temporary objects need a public destructor.
Protected destructor also prevents access to delete HeapOnly because it internally invokes the destructor. To prevent memory leak, destroy member function is provided, which calls delete on itself. Derived classes have access to the protected destructor so HeapOnly class can still be used as a base class. However, the derived class no longer has the same restrictions.
Prohibiting heap-based objects
Dynamic allocation of objects can be prevented by disallowing access to all forms of class-specific new operators. The new operator for scalar objects and for an array of objects are two possible variations. Both should be declared protected (or private) to prevent heap-based objects.
The above declaration of protected new operator prevents remaining compiler-generated versions, such as placement new and nothrow new. Declaring just the scalar new as protected is not sufficient because it still leaves the possibility of new NoHeap[1] open. Protected new operator prevents dynamic allocation of arrays of all sizes including size one.
Restricting access to the new operator also prevents derived classes from using dynamic memory allocation because the new operator and delete operator are inherited. Unless these functions are declared public in a derived class, that class inherits the protected/private versions declared in its base preventing dynamic allocation.
# Recursive Type Composition
### Intent
### References

Compile Time Recursive Objects in C++ - Jaakko Jarvi
# Resource Return
### Intent

To convey ownership transfer (of a resource) explicitly in the return type of a factory function.

### Motivation

Factory functions are often used to create new resources and return them to the caller. A new resource could be raw memory, dynamically allocated object, database cursors/connections, locks and so on. An important question about resources is who owns the resource and who releases it? Many times, interfaces are developed where the caller is implicitly responsible for resource release. If the caller is not aware of this fact or simply forgets to take correct steps, it gives rise to an easy-to-use-incorrectly kind of interface. Following code snippet shows an example.
Resource Return Idiom provides different alternatives to rectify the situation and results into (somewhat) hard-to-use-incorrectly interfaces.

### Solution and Sample Code

The solution is to wrap the resource in a resource-management smart pointer and return the smart pointer instead of the raw pointers. Simplest form of Resource Return Idiom is shown in the code snippet below.
There are several issues to be considered while determining the type of resource-management smart pointer to use to return a resource. Possible options are:
* std::auto_ptr
* boost::shared_ptr / std::shared_ptr (as of C++11)
* std::unique_ptr in C++0x
* User defined Handle/Body idiom
An excellent discussion of pros and cons of choosing one over the other are discussed at length by Scott Meyers in his article The Resource Return Problem. As long as custom deletion functionality (other than plain old delete) is not required, auto_ptrs are a quick way to use the Resource Return idiom as shown above. auto_ptrs give exclusive but transferable ownership of resources which becomes very clear just by looking at the interface. For dynamically allocated pointer-returning factory functions, boost::shared_ptr is a also good choice because it offers normal copy-semantics (e.g., it can be stored in STL containers). It also allows changes to resource release policy from normal delete operation to custom deletion without disturbing clients.
When exclusive ownership is involved in case of Resource Return idiom, Move Constructor idiom is often useful while transferring ownership of resources.

### Related Idioms

* Resource Acquisition Is Initialization (RAII)
* Move Constructor

### References

* The Resource Return Problem
# Return Type Resolver
### Intent

Deduce the type of the variable being initialized or assigned to.

### Motivation

The type of the variable being initialized can be a useful information to have in certain contexts. Consider, for instance, we want to initialize STL containers with random numbers. However, we don't know the exact type of the container expected by the user. It could be std::list, std::vector or something custom that behaves like STL container. A straight-forward approach to write and use such a function would be as follows.
Note that the type of the container must be passed to the function because that is the desired return type of the function. Clearly, the type must be repeated at-least twice. Return type resolver idiom can be used to address this issue.

### Solution and Sample Code

Return type resolver idiom makes use of a proxy class and templatized conversion operator functions in the class. getRandomN function above can be implemented with a class and a member conversion function as follows.
getRandomN class has a constructor and a templatized conversion operator function. For initialization, a temporary object of getRandomN class is created and assigned to the desired container class. C++ compiler attempts to convert the temporary object into the container class object. The only way to do that is via the conversion operator. The conversion operator is instantiated with the type of the container that is being populated. Due to automatic resolution of the return type, the user does not have to spell it out again. Note that insert member function has been used instead of push_back because std::set does not support push_back.

### Known Uses

The nullptr idiom makes use of the return type resolver idiom to automatically deduce a null pointer of the correct type depending upon the pointer variable it is assigning to.

### Related Idioms

* nullptr
# Runtime Static Initialization Order Idioms
### Intent

Control the order of initialization and destruction of non-local static objects across compilation units that are otherwise ordered in an implementation dependent manner.

### Motivation

* Order of initialization of static objects spread across different compilation units is not well defined. Order of destruction is the reverse of initialization order but initialization order itself is implementation defined. Bring order to this chaos.
* The destructor of static objects are non-trivial and have important side-effects that have to happen

### Solution and Sample Code

The following idioms are commonly used to control the order of initialization of static objects.
* Construct On First Use
* Nifty Counter Idiom (a.k.a. Schwarz Counter Idiom)
# More C++ Idioms/Promotion Ladder
## References

http://users.rcn.com/jcoplien/Patterns/C++Idioms/EuroPLoP98.html#PromotionLadder
# MythTV/Conclusion

* MythTV Introduction | Getting Started | Installing | Extras | Troubleshooting | Conclusion
Installing and configuring MythTV can be a challenge. However, there's no denying that having a functional MythTV is both a matter of fun and pride. There's so much a MythTV can do, that you'll be happily playing and tinkering for a while to come. Also, most users of MythTV note that they change their viewing habits entirely. Instead of watching TV based on the network's choices, you can watch on your own schedule. This doesn't necessarily mean you'll watch more TV. Rather, you'll find that the time you spend watching TV is better spent. You watch quality shows and don't waste time surfing, unable to find something interesting on TV when you are in the mood to watch. You'll also be amazed how many good shows and movies routinely play on TV (especially at odd hours). By using your MythTV, you'll be able to finally take full advantage of your subscription to cable or satellite television. It's a liberating experience, especially because you're in full control of both your TV viewing experience, and the hardware/software that makes it all possible. So enjoy it!
# MythTV

* MythTV Introduction | Getting Started | Installing | Extras | Troubleshooting | Conclusion
Welcome to the MythTV Wikibook! Here you can find out how to setup, install, and configure a MythTV for use in a variety of situations. Please begin by reading the Introduction and progressing through the rest of the sections by using the menu at the top of every page.
# OpenMP/Overview

This book is about OpenMP, a language extension to C (and C++) that allows for easy parallel programming. To understand what OpenMP makes possible, it is first important to know what parallel programming is and what it isn't.
Parallel programming means writing software that operates on several compute devices at the same time. For the purpose of this book, a "compute device" is primarily a processor (CPU) or a processor core within a multicore CPU, which is the focus of OpenMP 3. In other settings, a compute device may mean a full-blown computer within a cluster of computers, or a different type of device such as a graphic processing unit (GPU). An extension of OpenMP to cluster computing has been devised by Intel, and OpenMP 4 adds supports for executing code on non-CPU devices, but these are outside the scope of this book.
Parallel programming is mainly done to speed up computations that have to be fast. Ideally, if you have n compute devices (cores) to run a program, you'd want the program to be n times as fast as when it runs on a single device. This ideal situation never occurs in practice because the compute devices need to communicate with each other, sending and waiting for messages such as "give me the result of your computation". Still, parallel programming can speed up many applications by a factor almost equal to n.
Parallel programming should be distinguished from concurrent programming, which means breaking down a program into processes that conceptually run at the same time. There is considerable overlap between parallel and concurrent programs: both involve decomposing a task into distinct subtasks that can be executed separately, and concurrent programs can benefit from having their tasks run on multiple compute devices in parallel. However, full concurrent programming is a different art from that of parallel programming in that usually, different types of communication occur between concurrent tasks than between parallel tasks.
OpenMP adds support for parallel programming to C in a very clean way. Unlike thread libraries, little change is needed to existing programs to have them run on multiple processors in parallel. In fact, the basic constructs of OpenMP are so non-intrusive that programs using them but compiled by a compiler that doesn't support OpenMP will still work (although sequentially, of course). To see what that means, consider the following C function:
This function "broadcasts" the sine function over an array, storing its results back into that same array. When OpenMP is enabled in the compiler, it will in fact do so using multiple threads, but without OpenMP, it will still function and produce the exact same effect.
OpenMP programs work according to a so-called fork–join model, illustrated on the right. The OpenMP runtime maintains a thread pool, and every time a parallel section is encountered, it distributes work over the threads in the pool. When all threads are done, sequential execution is resumed.
# OpenGL Programming/reference/basic testing app

This is the basic opengl testing app to use with examples in the function reference section.
To run many examples you will only need to replace the setup or display function.