An Initial Heading

Let's examine a basic concept. We will focus on how to reword content in MDX files. The key is to maintain the original meaning.

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

Here's an image:

And now, a link to Google.

Finally, we will see another paragraph. This paragraph serves as an example of more text. It helps to show how longer sections can be reworded.

This is a code block.

print("Hello, world!")

echo "Hello from bash"

<p>A paragraph of HTML</p>

{
 "key": "value"
}

const message: string = "Hello, TypeScript!";
console.log(message);

Console.WriteLine("Hello, C#!");

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

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

puts "Hello, Ruby!"

package main


import "fmt"


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

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

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

print("Hello, Swift!")

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

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


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

IO.puts "Hello, Elixir!"

print("Hello, Lua!")

print("Hello, R!")

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

print "Hello, Perl!\n";

console.log "Hello, CoffeeScript!"

printfn "Hello, F#!"

Module Program
 Sub Main()
 Console.WriteLine("Hello, VB.NET!")
 End Sub
End Module

Write-Host "Hello, PowerShell!"

(println "Hello, Clojure!")

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

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


section .text
 global _start


_start:
 ; Write the message to stdout
 mov eax, 4 ; sys_write syscall number
 mov ebx, 1 ; stdout file descriptor
 mov ecx, msg ; address of the message
 mov edx, 16 ; length of the message
 int 0x80 ; call the kernel


 ; Exit the program
 mov eax, 1 ; sys_exit syscall number
 xor ebx, ebx ; exit code 0
 int 0x80 ; call the kernel

#include <stdio.h>


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

#include <iostream>


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

#import <Foundation/Foundation.h>


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

with Ada.Text_IO; use Ada.Text_IO;


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

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

(print "Hello, Lisp!")

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

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

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

Transcript show: 'Hello, Smalltalk!'; cr.

puts "Hello, Tcl!"

library ieee;
use ieee.std_logic_1164.all;


entity hello is
end entity hello;


architecture behavioral of hello is
begin
 process
 begin
 report "Hello, VHDL!";
 wait; -- Stops simulation
 end process;
end architecture behavioral;

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

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

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

'Hello, APL!'

BEGIN { print "Hello, Awk!" }

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

import std.stdio;


void main() {
 writeln("Hello, D!");
}

program Hello;


begin
 Writeln('Hello, Delphi!');
 Readln;
end.

class
 HELLO


create
 make


feature


 make
 do
 print ("Hello, Eiffel!%N")
 end


end

." Hello, Forth!" cr
bye

println("Hello, Julia!")

// LabVIEW does not use text-based code.
// It uses a graphical programming language.
// This is a placeholder.

Print["Hello, Mathematica!"]

disp('Hello, MATLAB!');

#import <iostream>


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

print_endline "Hello, OCaml!";

program Hello is
begin
 write_string("Hello, PascaLIGO!");
end.

DECLARE
BEGIN
 DBMS_OUTPUT.PUT_LINE('Hello, PL/SQL!');
END;
/

/ Hello, Q!
/

#lang racket
(displayln "Hello, Racket!")

/* REXX */
say 'Hello, REXX!'

BEGIN
 OUTTEXT("Hello, Simula!");
 OUTIMAGE;
END

SELECT 'Hello, SQL!';

print("Hello, Stan!");

#include <systemc.h>


SC_MODULE(hello) {
 SC_CTOR(hello) {
 SC_THREAD(main_thread);
 }


 void main_thread() {
 std::cout << "Hello, SystemC!" << std::endl;
 sc_stop();
 }
};


int sc_main(int argc, char* argv[]) {
 hello h("hello_instance");
 sc_start();
 return 0;
}

const message: string = "Hello, TypeScript!";
console.log(message);

Module Program
 Sub Main()
 Console.WriteLine("Hello, Visual Basic!")
 End Sub
End Module

Print["Hello, Wolfram Language!"]