Rewritten MDX Example

Let's examine a basic MDX document that has been rephrased.

This is an example of bold text.

This is an example of italicized text.

Here's an example of a link to Google.

function greet(name) {
 return `Hello, ${name}!`;
}


console.log(greet("World"));

This concludes the rewritten MDX example. We hope it is helpful!

def add(a, b):
 return a + b


print(add(5, 3))

```bash
echo "This is a bash command"

{
 "name": "example",
 "value": 123
}

```html
<p>This is an HTML paragraph.</p>

```jsx
const MyComponent = () => {
 return (
 <div>
 <h1>Hello, JSX!</h1>
 </div>
 );
};

```typescript
function logMessage(message: string): void {
 console.log(message);
}


logMessage("Hello, TypeScript!");

```css
body {
 font-family: sans-serif;
}

```md
# Markdown Heading


This is a markdown paragraph.

```yaml
name: example
value: 456

```graphql
query {
 user {
 id
 name
 }
}

```csharp
using System;


public class Example
{
 public static void Main(string[] args)
 {
 Console.WriteLine("Hello, C#!");
 }
}

```java
public class Main {
 public static void main(String[] args) {
 System.out.println("Hello, Java!");
 }
}

```kotlin
fun main() {
 println("Hello, Kotlin!")
}

```swift
import Foundation


print("Hello, Swift!")

```go
package main


import "fmt"


func main() {
 fmt.Println("Hello, Go!")
}

```rust
fn main() {
 println!("Hello, Rust!");
}

```php
<?php
echo "Hello, PHP!";
?>

```ruby
puts "Hello, Ruby!"

```scala
object Main {
 def main(args: Array[String]): Unit = {
 println("Hello, Scala!")
 }
}

```perl
print "Hello, Perl!\n";

```r
print("Hello, R!\n")

```dart
void main() {
 print('Hello, Dart!');
}

```lua
print("Hello, Lua!")

```powershell
Write-Host "Hello, PowerShell!"

```coffeescript
console.log "Hello, CoffeeScript!"

```fsharp
printfn "Hello, F#!"

```elixir
IO.puts "Hello, Elixir!"

```clojure
(println "Hello, Clojure!")

```erlang
-module(hello).
-export([main/0]).


main() ->
 io:fwrite("Hello, Erlang!\n").

```haskell
main :: IO ()
main = putStrLn "Hello, Haskell!"

```julia
println("Hello, Julia!")

```objectivec
#import <Foundation/Foundation.h>


int main(int argc, const char * argv[]) {
 @autoreleasepool {
 NSLog(@"Hello, Objective-C!");
 }
 return 0;
}

```ada
with Ada.Text_IO; use Ada.Text_IO;


procedure Hello is
begin
 Put_Line ("Hello, Ada!");
end Hello;

```assembly
section .data
 msg db "Hello, Assembly!", 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 16 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, Fortran!"
end program hello

```lisp
(print "Hello, Lisp!")

```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.

```prolog
:- initialization(main).


main :-
 write('Hello, Prolog!'), nl.

```scheme
(display "Hello, Scheme!")
(newline)

```tcl
puts "Hello, Tcl!"

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 -- VHDL doesn't typically print directly to console in a synthesizable way
 -- This is just a placeholder
 process
 begin
 wait; -- Wait forever
 end process;
end Behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, Verilog!");
 $finish;
 end
endmodule

```crystal
puts "Hello, Crystal!"

```nim
echo "Hello, Nim!"

```vala
int main() {
 print("Hello, Vala!\n");
 return 0;
}

```awk
BEGIN { print "Hello, Awk!" }

```batch
@echo off
echo Hello, Batch!

```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)


message("Hello, CMake!")

```dockerfile
FROM alpine:latest


CMD ["echo", "Hello, Docker!"]

```terraform
output "message" {
 value = "Hello, Terraform!"
}

```ansible
- hosts: all
 tasks:
 - name: Print a message
 debug:
 msg: "Hello, Ansible!"

```latex
\documentclass{article}
\begin{document}
Hello, LaTeX!
\end{document}

```mathematica
Print["Hello, Mathematica!"]

```matlab
disp('Hello, MATLAB!')

```simulink
% Simulink doesn't directly print to console.
% This is a placeholder comment.
% Create a Display block and connect a Constant block with value "Hello, Simulink!"

```scratch
% Scratch is a visual programming language, so direct text output isn't standard.
% This is a placeholder comment.
% Use the "say" block to display "Hello, Scratch!"

```arduino
void setup() {
 Serial.begin(9600);
 Serial.println("Hello, Arduino!");
}


void loop() {
 // put your main code here, to run repeatedly:
}

```processing
void setup() {
 println("Hello, Processing!");
}


void draw() {
 // put drawing code here
}

```maxmsp
// Max/MSP doesn't directly print to console.
// This is a placeholder comment.
// Use a message box with "Hello, Max/MSP!"

```puredata
#N canvas 0 0 450 300 10;
#X obj 100 100 print Hello, PureData!;

```supercollider
"Hello, SuperCollider!".postln;

```chuck
<<< "Hello, ChucK!";

```openFrameworks
void setup(){
 ofLog(OF_LOG_NOTICE, "Hello, openFrameworks!");
}


void draw(){


}

```cinder
#include "cinder/app/App.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"


using namespace ci;
using namespace ci::app;


class BasicApp : public App {
 public:
 void setup() override {
 console() << "Hello, Cinder!" << std::endl;
 }


 void draw() override {
 gl::clear( Color( 0, 0, 0 ) );
 }
};


CINDER_APP( BasicApp, RendererGl )

```threejs
// Three.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Three.js!") in your JavaScript code.

```babylonjs
// Babylon.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Babylon.js!") in your JavaScript code.

```playcanvas
// PlayCanvas doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, PlayCanvas!") in your JavaScript code.

```phaser
// Phaser doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Phaser!") in your JavaScript code.

```unity
// Unity uses Debug.Log to print to the console.
// This is a placeholder comment.
// Use Debug.Log("Hello, Unity!") in your C# script.

```unrealengine
// Unreal Engine uses UE_LOG to print to the output log.
// This is a placeholder comment.
// Use UE_LOG(LogTemp, Warning, TEXT("Hello, Unreal Engine!")); in your C++ code.

```godot
# Godot uses print() to print to the console.
# This is a placeholder comment.
# Use print("Hello, Godot!") in your GDScript code.

```construct
// Construct doesn't directly print to console.
// This is a placeholder comment.
// Use the "Log to console" action to display "Hello, Construct!"

```gamemaker
// GameMaker uses show_debug_message to print to the console.
// This is a placeholder comment.
// Use show_debug_message("Hello, GameMaker!"); in your GML code.

```renpy
# Ren'Py uses the "say" statement to display text.
# This is a placeholder comment.
# Use "e "Hello, Ren'Py!"" in your Ren'Py script.

```twine
:: Start
Hello, Twine!

```inform7
"Hello, Inform 7!"

```ink
Hello, Ink!

```bitsy
Hello, Bitsy!

```pico8
print("Hello, PICO-8!")

```tic80
print("Hello, TIC-80!")

```lex
%%
.|\n ECHO;
%%
int main() {
 yylex();
 return 0;
}

```yacc
%{
#include <stdio.h>
%}


%%
line : WORD { printf("Hello, Yacc!\n"); return 0; };
%%


int main() {
 yyparse();
 return 0;
}


int yyerror(char *s) {
 fprintf(stderr, "error: %s\n", s);
 return 0;
}

```antlr
grammar Hello;


r  : 'hello' ID ;
ID : [a-z]+ ;
WS : [ \t\r\n]+ -> skip ;

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```assembly
section .data
 msg db "Hello, Assembly!", 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 16 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, Fortran!"
end program hello

```lisp
(print "Hello, Lisp!")

```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.

```prolog
:- initialization(main).


main :-
 write('Hello, Prolog!'), nl.

```scheme
(display "Hello, Scheme!")
(newline)

```tcl
puts "Hello, Tcl!"

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 -- VHDL doesn't typically print directly to console in a synthesizable way
 -- This is just a placeholder
 process
 begin
 wait; -- Wait forever
 end process;
end Behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, Verilog!");
 $finish;
 end
endmodule

```crystal
puts "Hello, Crystal!"

```nim
echo "Hello, Nim!"

```vala
int main() {
 print("Hello, Vala!\n");
 return 0;
}

```awk
BEGIN { print "Hello, Awk!" }

```batch
@echo off
echo Hello, Batch!

```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)


message("Hello, CMake!")

```dockerfile
FROM alpine:latest


CMD ["echo", "Hello, Docker!"]

```terraform
output "message" {
 value = "Hello, Terraform!"
}

```ansible
- hosts: all
 tasks:
 - name: Print a message
 debug:
 msg: "Hello, Ansible!"

```latex
\documentclass{article}
\begin{document}
Hello, LaTeX!
\end{document}

```mathematica
Print["Hello, Mathematica!"]

```matlab
disp('Hello, MATLAB!')

```simulink
% Simulink doesn't directly print to console.
% This is a placeholder comment.
% Create a Display block and connect a Constant block with value "Hello, Simulink!"

```scratch
% Scratch is a visual programming language, so direct text output isn't standard.
% This is a placeholder comment.
% Use the "say" block to display "Hello, Scratch!"

```arduino
void setup() {
 Serial.begin(9600);
 Serial.println("Hello, Arduino!");
}


void loop() {
 // put your main code here, to run repeatedly:
}

```processing
void setup() {
 println("Hello, Processing!");
}


void draw() {
 // put drawing code here
}

```maxmsp
// Max/MSP doesn't directly print to console.
// This is a placeholder comment.
// Use a message box with "Hello, Max/MSP!"

```puredata
#N canvas 0 0 450 300 10;
#X obj 100 100 print Hello, PureData!;

```supercollider
"Hello, SuperCollider!".postln;

```chuck
<<< "Hello, ChucK!";

```openFrameworks
void setup(){
 ofLog(OF_LOG_NOTICE, "Hello, openFrameworks!");
}


void draw(){


}

```cinder
#include "cinder/app/App.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"


using namespace ci;
using namespace ci::app;


class BasicApp : public App {
 public:
 void setup() override {
 console() << "Hello, Cinder!" << std::endl;
 }


 void draw() override {
 gl::clear( Color( 0, 0, 0 ) );
 }
};


CINDER_APP( BasicApp, RendererGl )

```threejs
// Three.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Three.js!") in your JavaScript code.

```babylonjs
// Babylon.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Babylon.js!") in your JavaScript code.

```playcanvas
// PlayCanvas doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, PlayCanvas!") in your JavaScript code.

```phaser
// Phaser doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Phaser!") in your JavaScript code.

```unity
// Unity uses Debug.Log to print to the console.
// This is a placeholder comment.
// Use Debug.Log("Hello, Unity!") in your C# script.

```unrealengine
// Unreal Engine uses UE_LOG to print to the output log.
// This is a placeholder comment.
// Use UE_LOG(LogTemp, Warning, TEXT("Hello, Unreal Engine!")); in your C++ code.

```godot
# Godot uses print() to print to the console.
# This is a placeholder comment.
# Use print("Hello, Godot!") in your GDScript code.

```construct
// Construct doesn't directly print to console.
// This is a placeholder comment.
// Use the "Log to console" action to display "Hello, Construct!"

```gamemaker
// GameMaker uses show_debug_message to print to the console.
// This is a placeholder comment.
// Use show_debug_message("Hello, GameMaker!"); in your GML code.

```renpy
# Ren'Py uses the "say" statement to display text.
# This is a placeholder comment.
# Use "e "Hello, Ren'Py!"" in your Ren'Py script.

```twine
:: Start
Hello, Twine!

```inform7
"Hello, Inform 7!"

```ink
Hello, Ink!

```bitsy
Hello, Bitsy!

```pico8
print("Hello, PICO-8!")

```tic80
print("Hello, TIC-80!")

```lex
%%
.|\n ECHO;
%%
int main() {
 yylex();
 return 0;
}

```yacc
%{
#include <stdio.h>
%}


%%
line : WORD { printf("Hello, Yacc!\n"); return 0; };
%%


int main() {
 yyparse();
 return 0;
}


int yyerror(char *s) {
 fprintf(stderr, "error: %s\n", s);
 return 0;
}

```antlr
grammar Hello;


r  : 'hello' ID ;
ID : [a-z]+ ;
WS : [ \t\r\n]+ -> skip ;

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```assembly
section .data
 msg db "Hello, Assembly!", 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 16 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, Fortran!"
end program hello

```lisp
(print "Hello, Lisp!")

```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.

```prolog
:- initialization(main).


main :-
 write('Hello, Prolog!'), nl.

```scheme
(display "Hello, Scheme!")
(newline)

```tcl
puts "Hello, Tcl!"

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 -- VHDL doesn't typically print directly to console in a synthesizable way
 -- This is just a placeholder
 process
 begin
 wait; -- Wait forever
 end process;
end Behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, Verilog!");
 $finish;
 end
endmodule

```crystal
puts "Hello, Crystal!"

```nim
echo "Hello, Nim!"

```vala
int main() {
 print("Hello, Vala!\n");
 return 0;
}

```awk
BEGIN { print "Hello, Awk!" }

```batch
@echo off
echo Hello, Batch!

```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)


message("Hello, CMake!")

```dockerfile
FROM alpine:latest


CMD ["echo", "Hello, Docker!"]

```terraform
output "message" {
 value = "Hello, Terraform!"
}

```ansible
- hosts: all
 tasks:
 - name: Print a message
 debug:
 msg: "Hello, Ansible!"

```latex
\documentclass{article}
\begin{document}
Hello, LaTeX!
\end{document}

```mathematica
Print["Hello, Mathematica!"]

```matlab
disp('Hello, MATLAB!')

```simulink
% Simulink doesn't directly print to console.
% This is a placeholder comment.
% Create a Display block and connect a Constant block with value "Hello, Simulink!"

```scratch
% Scratch is a visual programming language, so direct text output isn't standard.
% This is a placeholder comment.
% Use the "say" block to display "Hello, Scratch!"

```arduino
void setup() {
 Serial.begin(9600);
 Serial.println("Hello, Arduino!");
}


void loop() {
 // put your main code here, to run repeatedly:
}

```processing
void setup() {
 println("Hello, Processing!");
}


void draw() {
 // put drawing code here
}

```maxmsp
// Max/MSP doesn't directly print to console.
// This is a placeholder comment.
// Use a message box with "Hello, Max/MSP!"

```puredata
#N canvas 0 0 450 300 10;
#X obj 100 100 print Hello, PureData!;

```supercollider
"Hello, SuperCollider!".postln;

```chuck
<<< "Hello, ChucK!";

```openFrameworks
void setup(){
 ofLog(OF_LOG_NOTICE, "Hello, openFrameworks!");
}


void draw(){


}

```cinder
#include "cinder/app/App.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"


using namespace ci;
using namespace ci::app;


class BasicApp : public App {
 public:
 void setup() override {
 console() << "Hello, Cinder!" << std::endl;
 }


 void draw() override {
 gl::clear( Color( 0, 0, 0 ) );
 }
};


CINDER_APP( BasicApp, RendererGl )

```threejs
// Three.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Three.js!") in your JavaScript code.

```babylonjs
// Babylon.js doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Babylon.js!") in your JavaScript code.

```playcanvas
// PlayCanvas doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, PlayCanvas!") in your JavaScript code.

```phaser
// Phaser doesn't directly print to console but relies on browser console.
// This is a placeholder comment.
// Use console.log("Hello, Phaser!") in your JavaScript code.

```unity
// Unity uses Debug.Log to print to the console.
// This is a placeholder comment.
// Use Debug.Log("Hello, Unity!") in your C# script.

```unrealengine
// Unreal Engine uses UE_LOG to print to the output log.
// This is a placeholder comment.
// Use UE_LOG(LogTemp, Warning, TEXT("Hello, Unreal Engine!")); in your C++ code.

```godot
# Godot uses print() to print to the console.
# This is a placeholder comment.
# Use print("Hello, Godot!") in your GDScript code.

```construct
// Construct doesn't directly print to console.
// This is a placeholder comment.
// Use the "Log to console" action to display "Hello, Construct!"

```gamemaker
// GameMaker uses show_debug_message to print to the console.
// This is a placeholder comment.
// Use show_debug_message("Hello, GameMaker!"); in your GML code.

```renpy
# Ren'Py uses the "say" statement to display text.
# This is a placeholder comment.
# Use "e "Hello, Ren'Py!"" in your Ren'Py script.

```twine
:: Start
Hello, Twine!

```inform7
"Hello, Inform 7!"

```ink
Hello, Ink!

```bitsy
Hello, Bitsy!

```pico8
print("Hello, PICO-8!")

```tic80
print("Hello, TIC-80!")

```lex
%%
.|\n ECHO;
%%
int main() {
 yylex();
 return 0;
}

```yacc
%{
#include <stdio.h>
%}


%%
line : WORD { printf("Hello, Yacc!\n"); return 0; };
%%


int main() {
 yyparse();
 return 0;
}


int yyerror(char *s) {
 fprintf(stderr, "error: %s\n", s);
 return 0;
}

```antlr
grammar Hello;


r  : 'hello' ID ;
ID : [a-z]+ ;
WS : [ \t\r\n]+ -> skip ;

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```awk
BEGIN { print "Hello, Awk!" }

```sed
s/^/Hello, Sed!/

```jq
"Hello, jq!"

```assembly
section .data
 msg db "Hello, Assembly!", 0


section .text
 global _start


_start:
 ; Write the message to stdout
 mov rax, 1  ; syscall number for write
 mov rdi, 1  ; file descriptor 1 is stdout
 mov rsi, msg ; address of string to output
 mov rdx, 16 ; number of bytes to write
 syscall


 ; Exit the program
 mov rax, 60 ; syscall number for exit
 xor rdi, rdi ; exit code 0
 syscall

```fortran
program hello
 print *, "Hello, Fortran!"
end program hello

```lisp
(print "Hello, Lisp!")

```pascal
program Hello;
begin
 writeln('Hello, Pascal!');
end.

```prolog
:- initialization(main).


main :-
 write('Hello, Prolog!'), nl.

```scheme
(display "Hello, Scheme!")
(newline)

```tcl
puts "Hello, Tcl!"

```vhdl
library ieee;
use ieee.std_logic_1164.all;


entity hello is
end hello;


architecture Behavioral of hello is
begin
 -- VHDL doesn't typically print directly to console in a synthesizable way
 -- This is just a placeholder
 process
 begin
 wait; -- Wait forever
 end process;
end Behavioral;

```verilog
module hello;
 initial begin
 $display("Hello, Verilog!");
 $finish;
 end
endmodule

```crystal
puts "Hello, Crystal!"

```nim
echo "Hello, Nim!"

```vala
int main() {
 print("Hello, Vala!\n");
 return 0;
}

```awk
BEGIN { print "Hello, Awk!" }

```batch
@echo off
echo Hello, Batch!

```cmake
cmake_minimum_required(VERSION 3.0)
project(HelloWorld)


message("Hello, CMake!")

```dockerfile
FROM alpine:latest


CMD ["echo", "Hello, Docker!"]

```terraform
output "message" {
 value = "Hello, Terraform!"
}

```ansible
- hosts: all
 tasks:
 - name: Print a message
 debug:
 msg: "Hello, Ansible!"

```latex
\documentclass{article}
\begin{document}
Hello, LaTeX!
\end{document}

```mathematica
Print["Hello, Mathematica!"]

```matlab
disp('Hello, MATLAB!')

```simulink
% Simulink doesn't directly print to console.
% This is a placeholder comment.
% Create a Display block and connect a Constant block with value "Hello, Simulink!"

```scratch
% Scratch is a visual programming language, so direct text output isn't standard.
% This is a placeholder comment.
% Use the "say" block to display "Hello, Scratch!"

```arduino
void setup() {
 Serial.begin(9600);
 Serial.println("Hello, Arduino!");
}


void loop() {
 // put your main code here, to run repeatedly:
}

```processing
void setup() {
 println("Hello, Processing!");
}


void draw() {
 // put drawing code here
}

```maxmsp
// Max/MSP doesn't directly print to console.
// This is a placeholder comment.
// Use a message box with "Hello, Max/MSP!"

```puredata
#N canvas 0 0 450 
<AppearanceSection></AppearanceSection>