WeixiangYan/CodeTransOcean huggingface dataset:
Task: Sockets



C#: using System;
using System.IO;
using System.Net.Sockets;

class Program {
    static void Main(string[] args) {
        TcpClient tcp = new TcpClient("localhost", 256);
        StreamWriter writer = new StreamWriter(tcp.GetStream());

        writer.Write("hello socket world");
        writer.Flush();

        tcp.Close();
    }
}









Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets

C: #include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

const char *msg = "hello socket world";

int main()
{
   int i, sock, len, slen;

   struct addrinfo hints, *addrs;  
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   
   if (0 == getaddrinfo("localhost", "256", &hints, &addrs))
   {
       sock = socket(addrs->ai_family, addrs->ai_socktype, addrs->ai_protocol);
       if ( sock >= 0 )
       {
           if ( connect(sock, addrs->ai_addr, addrs->ai_addrlen) >= 0 )
           {
               const char *pm = msg;
               do
               {
                  len = strlen(pm);
                  slen = send(sock, pm, len, 0);
                  pm += slen;
               } while ((0 <= slen) && (slen < len));
           }
           close(sock);
       }
       freeaddrinfo(addrs);
   }
}











Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets


C++: 

#include <boost/asio.hpp>

int main()
{
  boost::asio::io_context io_context;
  boost::asio::ip::tcp::socket sock(io_context);
  boost::asio::ip::tcp::resolver resolver(io_context);
  boost::asio::ip::tcp::resolver::query query("localhost", "4321");

  boost::asio::connect(sock, resolver.resolve(query));
  boost::asio::write(sock, boost::asio::buffer("Hello world socket\r\n"));

  return 0;
}










Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets




Go: package main
 
import (
    "fmt"
    "net"
)
 
func main() {
    conn, err := net.Dial("tcp", "localhost:256")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
    _, err = conn.Write([]byte("hello socket world"))
    if err != nil {
        fmt.Println(err)
    }
}








Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets





Java: import java.io.IOException;
import java.net.*;
public class SocketSend {
  public static void main(String args[]) throws IOException {
    sendData("localhost", "hello socket world");
  }

  public static void sendData(String host, String msg) throws IOException {
    Socket sock = new Socket( host, 256 );
    sock.getOutputStream().write(msg.getBytes());
    sock.getOutputStream().flush();
    sock.close();
  }
}







Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets







Python: import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("localhost", 256))
sock.sendall("hello socket world") 
sock.close()





Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets








VB: Imports System
Imports System.IO
Imports System.Net.Sockets

Public Class Program 
    Public Shared Sub Main(ByVal args As String[])
        Dim tcp As New TcpClient("localhost", 256)
        Dim writer As New StreamWriter(tcp.GetStream())

        writer.Write("hello socket world")
        writer.Flush()

        tcp.Close()
    End Sub
End Class




Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Sockets

C: #include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

const char *msg = "hello socket world";

int main()
{
   int i, sock, len, slen;

   struct addrinfo hints, *addrs;  
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   
   if (0 == getaddrinfo("localhost", "256", &hints, &addrs))
   {
       sock = socket(addrs->ai_family, addrs->ai_socktype, addrs->ai_protocol);
       if ( sock >= 0 )
       {
           if ( connect(sock, addrs->ai_addr, addrs->ai_addrlen) >= 0 )
           {
               const char *pm = msg;
               do
               {
                  len = strlen(pm);
                  slen = send(sock, pm, len, 0);
                  pm += slen;
               } while ((0 <= slen) && (slen < len));
           }
           close(sock);
       }
       freeaddrinfo(addrs);
   }
}
Task: Sockets



C#: using System;
using System.IO;
using System.Net.Sockets;

class Program {
    static void Main(string[] args) {
        TcpClient tcp = new TcpClient("localhost", 256);
        StreamWriter writer = new StreamWriter(tcp.GetStream());

        writer.Write("hello socket world");
        writer.Flush();

        tcp.Close();
    }
}
Task: Sockets


C++: 

#include <boost/asio.hpp>

int main()
{
  boost::asio::io_context io_context;
  boost::asio::ip::tcp::socket sock(io_context);
  boost::asio::ip::tcp::resolver resolver(io_context);
  boost::asio::ip::tcp::resolver::query query("localhost", "4321");

  boost::asio::connect(sock, resolver.resolve(query));
  boost::asio::write(sock, boost::asio::buffer("Hello world socket\r\n"));

  return 0;
}
Task: Sockets





Java: import java.io.IOException;
import java.net.*;
public class SocketSend {
  public static void main(String args[]) throws IOException {
    sendData("localhost", "hello socket world");
  }

  public static void sendData(String host, String msg) throws IOException {
    Socket sock = new Socket( host, 256 );
    sock.getOutputStream().write(msg.getBytes());
    sock.getOutputStream().flush();
    sock.close();
  }
}
Task: Sockets







Python: import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("localhost", 256))
sock.sendall("hello socket world") 
sock.close()
Task: Sockets








VB: Imports System
Imports System.IO
Imports System.Net.Sockets

Public Class Program 
    Public Shared Sub Main(ByVal args As String[])
        Dim tcp As New TcpClient("localhost", 256)
        Dim writer As New StreamWriter(tcp.GetStream())

        writer.Write("hello socket world")
        writer.Flush()

        tcp.Close()
    End Sub
End Class
Task: Sockets




Go: package main
 
import (
    "fmt"
    "net"
)
 
func main() {
    conn, err := net.Dial("tcp", "localhost:256")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
    _, err = conn.Write([]byte("hello socket world"))
    if err != nil {
        fmt.Println(err)
    }
}
Task: Sockets






PHP: $socket = fsockopen('localhost', 256);
fputs($socket, 'hello socket world');
fclose($socket);
Task: Sockets






PHP: $socket = fsockopen('localhost', 256);
fputs($socket, 'hello socket world');
fclose($socket);






Ada: with GNAT.Sockets;  use GNAT.Sockets;

procedure Socket_Send is
   Client : Socket_Type;
begin
   Initialize;
   Create_Socket  (Socket => Client);
   Connect_Socket (Socket => Client,
                   Server => (Family => Family_Inet,
                              Addr   => Inet_Addr ("127.0.0.1"),
                              Port   => 256));
   String'Write (Stream (Client), "hello socket world");
   Close_Socket (Client);
end Socket_Send;
Task: Caesar cipher



C#: using System;
using System.Linq;

namespace CaesarCypher
{
    class Program
    {
        static char Encrypt(char ch, int code)
        {
            if (!char.IsLetter(ch)) return ch;

            char offset = char.IsUpper(ch) ? 'A' : 'a';
            return (char)((ch + code - offset) % 26 + offset);
        }

        static string Encrypt(string input, int code)
        {
            return new string(input.Select(ch => Encrypt(ch, code)).ToArray());
        }

        static string Decrypt(string input, int code)
        {
            return Encrypt(input, 26 - code);
        }

        const string TestCase = "Pack my box with five dozen liquor jugs.";

        static void Main()
        {
            string str = TestCase;

            Console.WriteLine(str);
            str = Encrypt(str, 5);
            Console.WriteLine("Encrypted: " + str);
            str = Decrypt(str, 5);
            Console.WriteLine("Decrypted: " + str);
            Console.ReadKey();
        }
    }
}









Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;
Task: Caesar cipher

C: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define caesar(x) rot(13, x)
#define decaesar(x) rot(13, x)
#define decrypt_rot(x, y) rot((26-x), y)

void rot(int c, char *str)
{
	int l = strlen(str);
        
        const char*  alpha_low  = "abcdefghijklmnopqrstuvwxyz"; 

        const char*  alpha_high = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   
       
       char subst;  
       int idx;    

         int i; 

	for (i = 0; i < l; i++)  
	{
		if( 0 == isalpha(str[i]) )  continue; 

                idx = (int) (tolower(str[i]) - 'a') + c) % 26; 

		if( isupper(str[i]) )
                    subst = alpha_high[idx]; 
                else
                    subst = alpha_low[idx]; 

               str[i] = subst;

	}
}


int main(int argc, char** argv)
{
	char str[] = "This is a top secret text message!";
	
	printf("Original: %s\n", str);
	caesar(str);
	printf("Encrypted: %s\n", str);
	decaesar(str);
	printf("Decrypted: %s\n", str);
	
	return 0;
}











Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;
Task: Caesar cipher


C++: #include <string>
#include <iostream>
#include <algorithm>
#include <cctype>

class MyTransform {
private : 
   int shift ;
public :
   MyTransform( int s ) : shift( s ) { } 

  char operator( )( char c ) {
      if ( isspace( c ) ) 
	 return ' ' ;
      else {
	 static std::string letters( "abcdefghijklmnopqrstuvwxyz" ) ;
	 std::string::size_type found = letters.find(tolower( c )) ;
	 int shiftedpos = ( static_cast<int>( found ) + shift ) % 26 ;
	 if ( shiftedpos < 0 ) 
	    shiftedpos = 26 + shiftedpos ;
	 char shifted = letters[shiftedpos] ;
	 return shifted ;
      }
  }
} ;

int main( ) {
   std::string input ;
   std::cout << "Which text is to be encrypted ?\n" ;
   getline( std::cin , input ) ;
   std::cout << "shift ?\n" ;
   int myshift = 0 ;
   std::cin >> myshift ;
   std::cout << "Before encryption:\n" << input << std::endl ;
   std::transform ( input.begin( ) , input.end( ) , input.begin( ) ,
	 MyTransform( myshift ) ) ;
   std::cout << "encrypted:\n" ;
   std::cout << input << std::endl ;
   myshift *= -1 ; 
   std::transform ( input.begin( ) , input.end( ) , input.begin( ) ,
	 MyTransform( myshift ) ) ;
   std::cout << "Decrypted again:\n" ;
   std::cout << input << std::endl ;
   return 0 ;
}










Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;
Task: Caesar cipher




Go: package main

import (
    "fmt"
    "strings"
)

type ckey struct {
    enc, dec func(rune) rune
}

func newCaesar(k int) (*ckey, bool) {
    if k < 1 || k > 25 {
        return nil, false
    }
    rk := rune(k)
    return &ckey{
        enc: func(c rune) rune {
            if c >= 'a' && c <= 'z'-rk || c >= 'A' && c <= 'Z'-rk {
                return c + rk
            } else if c > 'z'-rk && c <= 'z' || c > 'Z'-rk && c <= 'Z' {
                return c + rk - 26
            }
            return c
        },
        dec: func(c rune) rune {
            if c >= 'a'+rk && c <= 'z' || c >= 'A'+rk && c <= 'Z' {
                return c - rk
            } else if c >= 'a' && c < 'a'+rk || c >= 'A' && c < 'A'+rk {
                return c - rk + 26
            }
            return c
        },
    }, true
}

func (ck ckey) encipher(pt string) string {
    return strings.Map(ck.enc, pt)
}

func (ck ckey) decipher(ct string) string {
    return strings.Map(ck.dec, ct)
}

func main() {
    pt := "The five boxing wizards jump quickly"
    fmt.Println("Plaintext:", pt)
    for _, key := range []int{0, 1, 7, 25, 26} {
        ck, ok := newCaesar(key)
        if !ok {
            fmt.Println("Key", key, "invalid")
            continue
        }
        ct := ck.encipher(pt)
        fmt.Println("Key", key)
        fmt.Println("  Enciphered:", ct)
        fmt.Println("  Deciphered:", ck.decipher(ct))
    }
}








Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;
Task: Caesar cipher





Java: public class Cipher {
    public static void main(String[] args) {

        String str = "The quick brown fox Jumped over the lazy Dog";

        System.out.println( Cipher.encode( str, 12 ));
        System.out.println( Cipher.decode( Cipher.encode( str, 12), 12 ));
    }

    public static String decode(String enc, int offset) {
        return encode(enc, 26-offset);
    }

    public static String encode(String enc, int offset) {
        offset = offset % 26 + 26;
        StringBuilder encoded = new StringBuilder();
        for (char i : enc.toCharArray()) {
            if (Character.isLetter(i)) {
                if (Character.isUpperCase(i)) {
                    encoded.append((char) ('A' + (i - 'A' + offset) % 26 ));
                } else {
                    encoded.append((char) ('a' + (i - 'a' + offset) % 26 ));
                }
            } else {
                encoded.append(i);
            }
        }
        return encoded.toString();
    }
}







Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;
Task: Caesar cipher







Python: fun caesar(s, k, decode: false):
    if decode:
        k = 26 - k
    result = ''
    for i in s.uppercase() where 65 <= ord(i) <= 90:
        result.push! char(ord(i) - 65 + k) mod 26 + 65
    return result

let message = "The quick brown fox jumped over the lazy dogs"
let encrypted = caesar(msg, 11)
let decrypted = caesar(enc, 11, decode: true)

print(message, encrypted, decrypted, sep: '\n')





Ada: with Ada.Text_IO;

procedure Caesar is

   type modulo26 is modulo 26;

   function modulo26 (Character: Character; Output: Character) return modulo26 is
   begin
      return modulo26 (Character'Pos(Character)+Character'Pos(Output));
   end modulo26;

   function Character(Val: in  modulo26; Output: Character)
                        return Character is
   begin
      return Character'Val(Integer(Val)+Character'Pos(Output));
   end Character;

   function crypt (Playn: String; Key: modulo26) return String is
      Ciph: String(Playn'Range);

   begin
      for I in Playn'Range loop
         case Playn(I) is
            when 'A' .. 'Z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'A');
            when 'a' .. 'z' =>
               Ciph(I) := Character(modulo26(Playn(I)+Key), 'a');
            when others =>
               Ciph(I) := Playn(I);
         end case;
      end loop;
      return Ciph;
   end crypt;

   Text:  String := Ada.Text_IO.Get_Line;
   Key: modulo26 := 3; 

begin 

   Ada.Text_IO.Put_Line("Playn 
   Text := crypt(Text, Key);
   Ada.Text_IO.Put_Line("Ciphertext 
   Ada.Text_IO.Put_Line("Decrypted Ciphertext ->" & crypt(Text, -Key));

end Caesar;