OpenLLM-France/wikimedia huggingface dataset:
# Simple Guide to Minecraft/Heath & Hunger

In Minecraft, the health gauge and monitor show the player's remaining health. It consists of a row of 10 heart icons, where each heart is divided into two halves, representing one health point each. In most game modes, including Survival, Hardcore (
Java Edition only), and Adventure, as well as for mobs (in-game creatures), the health meter is displayed using these hearts. Each heart represents two hit points, and when players or mobs take damage, they lose hit points. The damage can be a fraction of a heart, but anything less than 1 heart is not shown on the health bar. The maximum health points for a player are usually 20.
In Hardcore, hearts have it different texture.The Poison effect makes your hearts turn yellow while slowly damaging you, same with the Wither effect. Freezing in powder snow turns your heart icy blue.
Hunger is a player-specific feature (that doesn't apply to mobs) that affects certain abilities like health regeneration and sprinting. The player's hunger level is displayed as a hunger bar, located opposite the health bar, and consists of ten drumsticks. Each half of a drumstick represents one hunger point or half-unit of hunger, making a full bar equivalent to twenty hunger points. Hunger is replenished by eating food and decreases when the player performs actions like sprinting, digging, or attacking. The player's hunger level determines health regeneration and sprinting ability. When hunger is at 18 drumsticks, health regeneration occurs, but if it falls to 6 drumsticks, the player can no longer sprint. If the hunger bar reaches zero, the player's health starts to deplete. It's important to note that hunger does not deplete in Peaceful difficulty and regenerates if not at the maximum value.
The Hunger effect is received by eating rotten flesh, and it turns your hunger bar green/yellow. When you have the Hunger effect, your hunger depletes faster.
# Simple Guide to Minecraft/Manual of Style
## Page names

Begin all pages names with "Simple Guide to Minecraft/"
When referring to something within dimensions, start the page name with "Simple Guide to Minecraft/Overworld" "Simple Guide to Minecraft/Nether" or "Simple Guide to Minecraft/The End" depending on the dimension.
To link to the Minecraft Wiki, use template {{Simple Guide to Minecraft/Wiki}} to generate the template you see at the side.
# Simple Guide to Minecraft/Note on Difficulty Levels

Minecraft difficulty levels provide players with varying degrees of challenge and gameplay experience. Here is a summary of each difficulty level:

## Peaceful

The easiest difficulty level in Minecraft, Peaceful mode focuses on exploration and creativity. Players encounter no hostile mobs and have unlimited health and hunger, allowing for a relaxed and uninterrupted building experience.

## Easy

The Easy difficulty introduces some challenges while still being relatively forgiving. Hostile mobs spawn but deal reduced damage compared to higher difficulties. Players must manage their health and hunger but can still navigate the game world with moderate ease.

## Normal

Normal difficulty strikes a balance between challenge and accessibility. Hostile mobs are stronger and deal more damage, requiring players to exercise caution and employ effective resource management. Survival and success in the game become more dependent on strategic decision-making and understanding core mechanics.

## Hard

Hard mode presents a significant challenge, specifically designed for experienced players. Hostile mobs become even more formidable, dealing substantial damage. Players must constantly consume food to regenerate health, necessitating careful planning and resource allocation. Hard mode demands strategic thinking, efficient resource utilization, and precise execution to thrive in the perilous environment.

## Conclusion

Minecraft's difficulty levels cater to a wide range of player preferences, providing options for casual exploration, moderate challenges, intense gameplay, and the ultimate hardcore experience.
# Rexx Programming/How to Rexx/goto

Many languages have a "jump" instruction or a "goto statement" that skips to an arbitrary part of the program. Other languages completely replace the need for such a statement with more specific flow control constructs. Rexx mostly uses subroutines and DO/END blocks to jump around to different parts of the program, but it does have a more general kind of jump instruction. You can use the SIGNAL keyword to redirect the computer to a labeled location in the program. Labels end in a colon.
Long programs that depend on goto statements are notoriously difficult to understand in the long term. Stick with the structured control flow statements described elsewhere in this book, such as for loops. A more elegant way to write this script, without SIGNAL statements, might be as follows:
# Rexx Programming/How to Rexx/file
## Filename association

In rexx, filename association is used, rather than numeric filehandles to refer to open files or devices. The rexx interpreter make the appropriate mappings to filehandles behind the scenes.
# Rexx Programming/How to Rexx/for loop

"For" loops are also called "definite loops". They repeat the same block of code several times and stop. They are coded using the word "for" in many other languages, but in Rexx, they appear between the keywords DO and END, just like other blocks of code.
If we want the code to do something slightly different each time it runs, we can use a variable to keep track of the counting.
Rexx can also skip count by 2s, 3s, 4s, or some other amount.
If you don't want to specify the last number but rather just how many times you'd like to count, then Rexx does actually have a FOR keyword that you can use.
You can also nest definite loops inside each other for two or more levels of repetition.
# Rexx Programming/How to Rexx/function
## Function calls are followed by parentheses

Function calls are followed by parentheses containing optional parameters to the function. A pair of empty parentheses are used if the function has no optional parameters.

## Whitespace is not allowed between a function name and its argument list

The parentheses containing function arguments must immediately follow the function name. No whitespace characters are allowed between the function name and its argument list, otherwise the function name may get misinterpreted as a variable name:

## Functions always return a result

Functions in rexx always return a result which is substituted into the expression in place of the function call after the function has been executed. Some functions are already provided within Rexx for you to use, such as the RANDOM function used in the example above, or the ABS function which finds the absolute value of a number.

## Different types of functions

Rexx has built-in functions to process and return many different types of values, including numbers, Boolean values, or strings more generally. You have likely already seen some of them in different parts of this how-to.
You can also create your own function by coding it as a subroutine, as described elsewhere.
# Rexx Programming/How to Rexx/comment

Comments are helpful side notes within the code. They are meant for humans, not for computers. They have to be notated a certain way so that the computer will ignore them. In Rexx, a comment begins with a forward slash, followed by an asterisk (/*) and then with whatever you want to say. A comment ends with the same two characters in reverse order: a an asterisk, followed by a forward slash (*/).
If you think a section of code needs to be explained to the reader, you can write a comment nearby to summarize it or to point out important features. Historically, some Rexx interpreters have required every program to begin with a comment. You're likely to see many comments in example Rexx programs to explain what the Rexx code means for people who don't already know the language.
Since a slash-star comment must always end with a star-slash, it can be as long as want. Newlines will be ignored just like everything else inside the comment. Make sure to always close your comment when you've finished your message, so that you don't accidentally cause the interpreter to ignore a large, important part of your script.
Most programming languages have some way to include comments within the code. In fact, many programming languages use the same slash-star notation for comments that Rexx does. If you've programmed before, you might recognize this notation from C, C++, C#, Go, Java, JavaScript, Rust, or some other language. Those languages also have a second kind of comment that Rexx doesn't have: a comment that starts with two slashes and ends with a newline. A double-slash has a different meaning in Rexx, so be careful not to use it for comments.
# Rexx Programming/How to Rexx/comparative operator

The comparative operators are used to determine equality or inequality or otherwise make comparisons of numeric or string values, and produce a boolean truth based on the result. A true comparison evaluates to a value of one, whereas a false comparision evaluates to zero.

## Numeric or String Comparisons

The variables in rexx are typeless, so the interpreter decides whether to make a numeric or string comparison based upon the values of the operands to the operator being evaluated. If both operands contain a numeric value, then the comparison will be a numericcomparison, otherwise a stringcomparison will be made.
'21' = '21' /* 1 true, numeric comparison */ '021' = '21' /* 1 true, numeric comparison (leading zero ignored) */ ' 021 ' = '21' /* 1 true, numeric comparison (whitespace and leading zero ignored) */ '21' = '21.0' /* 1 true, numeric comparison (insignificant zero ignored) */ 'ABC' = 'Abc' /* 0 false, string comparison (case sensitive) */ ' ' = /* 1 true, string comparison (stripped whitespace matches null value) */ 'ABC' = ' ABC ' /* 1 true, string comparison (leading and trailing whitespace ignored) */

## Strict Comparison

The conventional stringcomparison operators ignore leading and trailing whitespace when the comparison is made:
' ' = /* 1 true, string comparison (stripped whitespace matches null value) */ 'ABC' = ' ABC ' /* 1 true, string comparison (leading and trailing whitespace ignored) */
The rexx interpreter provides support for strict comparative operators. The strict comparative operators do not ignore leading and trailing whitespace, which must also match when a strict comparison is made.
' ' == /* 0 false, strict comparison (the spaces will not match the null value) */ 'ABC' == ' ABC ' /* 0 false, strict comparison (leading and trailing whitespace causes mismatch) */
# Rexx Programming/How to Rexx/control structure

Control structures (also known as control constructs) are constructs used within a program to control the flow of a program based on given conditions. Control structure typically uses conditional branching instructions or loop control statements. Code within control structures is typically arranged into blocks in a similar fashion to control structures written in C.

## Conditional Branching

The following example shows a conditional code being used as a conditional branch:
Here is a conditional branch with two parts:
As mentioned earlier, we can use blocks so that more than one thing can happen if a condition is met (or unmet).

## Select

Rexx also has a construct for choosing the first true condition from multiple options.

## Loops

The following example shows a block of code being used in a loop:
# Rexx Programming/How to Rexx/doublequote

A double quote (") is a punctuation mark widely used to signal direct quotations in some written languages. In Rexx, it is used to signal string literals: values that are to be treated as is, without any computations happening inside them. In the following example, variable a will store the result of adding 3 to 5, whereas variable b will store the addition problem itself. Variable c will store the name of a certain European country.
The double quotes are not actually part of the string literal. They just surround the string literal so that the interpreter can recognize it. The following example would display the message "Hello world!" on the screen, but it would only display the greeting itself, not the quotation marks.
A string literal marked by double quotes can include apostrophes or single quote marks inside it:
Single quotes can be used to signal string literals, too, so you can use those if you'd like to include double quotes within a string literal:
# Rexx Programming/How to Rexx/conditional loop

A conditional loop tests for a condition around the loop, and repeatedly executes a block of instructions whilst the condition is true. Types of conditional loops include while loops, until loops and repeat loops.

## While loops

A while loop is a conditional loop that repeatedly executes a block of instructions whilst the condition is true. The while statement is used as a syntactical cocomponent of do and end constructs to produce a while loop:

## Until loops

An until loop is a conditionalloop that repeatedly executes a block of instructions until the condition is true. In Rexx, the until statement is used together with do and end constructs to produce an until loop:

## Repeat loops

A *repeat loop* is a [conditionalloop] that repeatedly executes a [block] of instructions whilst the condition is true. The [do] statement is used together with an [until] syntactical cocomponent to produce a repeat loop:

### The block of code within a repeat loop will always run at least once

Note than unlike [while] loops, with a repeat loop, the [condition] is evaluated after the [block] of code within the [loop]. even though it is written at the beginning. This means that the [block] of code within a repeat loop will always run at least once.

#### The cocomponents do and while are evaluated at the start of the loop

If a [do] and [while] cocomponents are used instead of [do] and [until], the loop will behave as a [while] loop with the condition being evaulated at the beginning of the loop. This may cause the loop to not execute at all, if the expression evaluates to a boolean [false] value:
# Rexx Programming/How to Rexx/datatype

There is, in principle, only one data type in Rexx: the character string. Strings represent letters, numerals, spaces, punctuation marks, and other kinds of text stored in the computers memory. In practice, Rexx recognizes several different forms of strings and can use them in different ways. So we can speak of different data types within the overall string type.

## Strings

Strings are sequences of text characters. They can be stored in variables, generated within a program, or directly written into the code using single or double quotation marks. Uninitialized variables are interpreted as uppercase versions of their own names.

## Numbers

Numbers are a special type of string. They are strings that just contain symbols people would use to represent numbers, such as digits, a negative sign, or a decimal point. Rexx can recognize number strings even if you don't use quotation marks.

## Testing the datatype

You can use the DATATYPE function test whether a value is just a character string or specifically a number string. It returns either CHAR or NUM, depending on which is the case.
You can also call the function with a second string, one letter long, to check for even more specific types of string:
* A = Alphanumeric: only letters and digits
* B = Binary: only zeros and ones
* L = Lowercase letters only
* M = Letters only (mixed case)
* N = Number
* U = Uppercase letters only
* W = Whole number
* X = Hexadecimal: digits and letters A-F
The DATATYPE function will return 1 if the first string actually matches that type or 0 if it doesn't.
# Pinyin/Video Camera

See also
# Pinyin/Vertebrate

Search Pinyin vertebrate
A vertebrate is an animal with a backbone. It is a branch of chordates. In general, the body shape of a vertebrate is symmetrical. Its body is divided into 3 parts: the head, the trunk, and the tail. Its trunk is divided by the diaphragm into the chest and abdomen. Vertebrates have excellent sense organs, motor organs and highly differentiated nervous system. Vertebrates Include fish, amphibians, reptiles, birds, mammals, and etc.
Jǐzhuīdòngwù shì yǒu jǐzhuīgǔ de dòngwù. Tā shì jísuǒdòngwù de yīgè fēnzhī. Jǐzhuīdòngwù yībān tǐxíng zuǒyòu duìchèn. Tā de shēntǐ fēnwéi 3 gè bùfèn: tóubù, qūgàn, wěibā. Tā de qūgàn bèi hénggémó fēnchéng xiōngbù hé fùbù. Jǐzhuīdòngwù yǒu bǐjiào wánshàn de gǎnjué qìguān, yùndòng qìguān hé gāodù fēnhuà de shénjīng xìtǒng. Jǐzhuīdòngwù bāokuò yúlèi, liǎngqīdòngwù, páxíngdòngwù, niǎolèi hé bǔrǔdòngwù děng.
# Pinyin/Victim

See also
# Pinyin/Very

See also
# Pinyin/Via

See also
# Pinyin/Vicinity

See also
# SPARC Assembly/Multiplication and Division

Looking through the lists of instructions, it becomes clear that multiplication and division operations are not provided in SPARC: at least not in a form that most programmers are familiar with. This page is going to discuss the algorithms used to perform multiplication and division operations in SPARC

## Example

To multiply %l3 and %l4 and store in %l5:
| mov | %l3 | %o0 | ! First operand |
| mov | %l4 | %o1 | ! Second operand |
| call | .mul | | ! Result stored in %o0 |
| | | | ! To divide %l3 by %l4, use .div |
| | | | ! To find the modulus, use .rem |
| nop | | | ! Delay slot |
| mov | %o0 | %l5 | ! Copy result to %l5 |
# SPARC Assembly/SPARC Architecture
## SPARC History

The first version of the architecture, SPARCv7 (for Scalable Processor Architecture, version 7), was originally developed by Sun Microsystems in 1986 ; the first implementation became available in 1987. In 1989, SPARC International, an independent, non-profit organization, was created to promote the SPARC and provide conformance testing. Implementations of the original 32-bit SPARC architecture were initially designed and used for Sun's Sun-4 workstation and server systems, replacing their earlier Sun-3 systems based on the Motorola 68000 family of processors. Later, SPARC processors were used in SMP servers produced by Sun Microsystems, Solbourne and Fujitsu, among others.
A new version, SPARCv8, was released in 1990. It added integer multiply and divide instructions, which weren't previously available, and quad-precision floating point numbers, encoded on 128 bits.
The specification of the first 64-bit version of the SPARC, SPARCv9, was published in 1994, and Sun and Fujitsu both started shipping SPARCv9 processors at the end of 1995.
SPARC International (http://sparc.org) was formed in 1989 to open up the SPARC architecture to make a larger ecosystem for the design. The architecture is freely licensable for a nominal fee. SPARC processors have been designed and produced by several manufacturers, including Texas Instruments, Atmel, Cypress Semiconductor, and Fujitsu. As a result of SPARC International, the SPARC architecture is fully open and non-proprietary.

## SPARC Architecture

The SPARC is of the Reduced Instruction Set Computing (RISC) architecture. The theory is that having the bare minimum of instructions needed to complete a job, the resulting architecture is faster, as most instructions take only one clock cycle to decode, leading to rapid execution. This is in contrast to CISC machines, which have specialized variable length instructions, and can take multiple clock cycles to decode and execute.
The SPARC architecture also prefetches instructions, having the next instruction fetched while the current one is executed. This has implication for branch instructions, as the next instruction might not be executed if the branch is taken, and this must be dealt with accordingly.

## Why SPARC?

Being a RISC architecture, SPARC assembly is very clean and simple, while still being powerful. This makes it easy to learn, and a good choice before learning more complicated assembly languages if needed. Furthermore, it provides a closer look of what is going on "under the hood" of higher-level programming languages, and at the very least should foster an appreciation of the large amount of work being done by compilers when compiling such languages. If you don't have a SPARC computer, you can use a SPARC emulator.
# SPARC Assembly/Pseudo-Ops

This page is going to discuss SPARC Pseudo-Ops.

## Pseudo-Ops

In addition to the SPARC instructions and synthetic instructions, there are a number of assembler-provided "Pseudo-Ops" that create convenience for the programmer.
* .ascii
* .asciz
* .text
* .data
* .bss
* .skip
* .align
* .byte
* .half
* .word
* .single
* .double
* .quad
* .global
* .common
* .empty
This chapter will (hopefully) discuss each of these.
# SPARC Assembly/Resources
## Wikimedia Resources

* wikipedia:assembler
* Programming:C
* C++
* Operating System Design
* Embedded Systems
* Reverse Engineering

## External Resources

* SPARC Architecture Manual, Version 9: http://developers.sun.com/solaris/articles/sparcv9.pdf
* Patterson and Hennessy, "Computer Organization and Design: Third Edition". Elsevier, 2005. ISBN 1558606941 Invalid ISBN
* Paul, Richard P. "SPARC Architecture, Assembly Language Programming, and C: Second Edition". Prentice Hall, 2000. ISBN 0130255963
# SPARC Assembly/SPARC Assemblers

This page is going to discuss some assemblers for programming SPARC Assembly.
# SPARC Assembly/SPARC Details
## Registers

SPARC processors have 32 integer registers. These registers are broken down into 4 basic categories: globals, locals, inputs, and outputs. The table below shows the general breakdown:
| Number | Purpose | Specific name |
| %r0–%r7 | Globals: accessible anywhere in a program | %g0–%g7 |
| %r8–%r15 | Outputs: used to pass values to/ obtain values from subroutines | %o0–%o7 |
| %r16–%r23 | Locals: used within subroutines to manipulate data | %l0–%l7 |
| %r24–%r31 | Inputs: contain data passed to a subroutine | %i0–%i7 |
Dispersed throughout these categories are several special purpose registers:
| Name | Number | Purpose | Pseudonym |
| Stack pointer | 14 | Pointer to the head of the stack. | %sp/ %o6 |
| Frame pointer | 30 | Pointer to the current stack frame. | %fp/ %i6 |
| Return address | 31 | Return address of the subroutine. | %i7 |
| Called return address | 15 | Return address of the called subroutine. | %o7 |
As you can see from the above tables, each register has at least two names, and some of the special purpose registers have three. Any of the available names for a given register is perfectly acceptable regardless of the usage context, and it is up to the programmer to choose which names to use at any particular time. Additionally, using the stack and frame pointer registers in a way other than which they were intended is not recommended and can cause severe functionality issues within a program.
SPARC processors also contain an array of floating-point registers and a small number of special-purpose registers. (further description needed here)

## Delayed Branch

SPARC processors are pipelined, and branching is accomplished through a technique called Delayed Branch Execution. Control Transfer Intructions (CTI) are any instruction that changes the current program counter. For instance, a jmp or call instruction are CTI instructions.
In SPARC, when a CTI instruction is executed, the jump is not handled immediately. Instead, there is a one cycle delay before the branch is executed. This means that the first instruction after the jump instruction is actually handled before the jump takes place. Here is an example:
Notice that the last instruction executes before the jump takes place, not after the subroutine returns. This first instruction after a jump is called a delay slot. It is common practice to fill the delay slot with a special operation that performs no task, called a no-operation, or nop.
| Instruction: | nop |
This instruction performs no action, and therefore we don't need to worry about what order it acts in. However, if we put a nop after every branch instruction, we will waste a lot of processor cycles. Therefore, if you can, it is always good practice to try to squeeze additional instructions into the delay slot, so that we don't waste any processor cycles.