Home

title: Reworded MDX Example description: This is a demonstration of how to reword MDX content while preserving its meaning.

Reworded MDX Example

Let's explore an example of how to rephrase MDX content while ensuring that its original meaning is maintained.

Code Blocks

Here's an example of a code block:

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


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

Images

Here's how to include an image:

Links

Here's a link to Google.

Lists

Here's an example of an unordered list:

Item 1
Item 2
Item 3

And here's an example of an ordered list:

First item
Second item
Third item

Conclusion

This demonstrates how to reword MDX while keeping the original meaning intact.

```javascript
function add(a, b) {
 return a + b;
}


console.log(add(5, 3));

```python
def multiply(x, y):
 return x * y


print(multiply(4, 6))

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

```csharp
using System;


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

```go
package main


import "fmt"


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

```ruby
puts "Hello, Ruby!"

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

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

```swift
print("Hello, Swift!")

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

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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!", 10, 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, 17 ; number of bytes to write
 syscall


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

```cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.
PROCEDURE DIVISION.
 DISPLAY "Hello, COBOL!".
 STOP RUN.

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

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

```prolog
hello :-
 write('Hello, Prolog!'), nl.

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

```haskell
main = putStrLn "Hello, Haskell!"

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

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


main() ->
 io:format("Hello, Erlang!~n").

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

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

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

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

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

```typescript
function sayHello(name: string): string {
 return `Hello, ${name}!`;
}


console.log(sayHello("TypeScript"));

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

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

```bash
echo "Hello, Bash!"

```c
#include <stdio.h>


int main() {
 printf("Hello, C!\n");
 return 0;
}

```cpp
#include <iostream>


int main() {
 std::cout << "Hello, C++!" << std::endl;
 return 0;
}

```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_
<AppearanceSection></AppearanceSection>