Language: C++

import java.io.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;

class Main {
    public static void main(String[] args) {
        solve();
        Stdin.flush();
    }

    static void solve() {
        char[] input = Stdin.receiveCharArray();
        Stdin.println(input[2] == input[3] && input[4] == input[5] ? "Yes" : "No");
    }

}

class Stdin {
    static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static final PrintWriter pw = new PrintWriter(System.out);

    public enum Delimiter {
        NONE(""), SPACE(" "), DOT("\\."), COMMA(",");

        private String regex;

        private Delimiter(String regex) {
            this.regex = regex;
        }

        public static Delimiter of(String input) {
            try {
                return Delimiter.valueOf(input.toUpperCase());
            } catch (IllegalArgumentException e) {
                return Arrays.stream(values()).filter(d -> d.getRegex().equals(input)).findFirst().orElse(SPACE);
            }
        }

        public String getRegex() {
            return regex;
        }
    }

    static String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
            throw new IllegalArgumentException(e);
        }
    }

    static int receiveInt() {
        return Integer.parseInt(nextLine());
    }

    static BigInteger receiveBigInteger() {
        return new BigInteger(nextLine());
    }

    static char receiveChar() {
        return nextLine().charAt(0);
    }

    static char[] receiveCharArray() {
        return nextLine().toCharArray();
    }

    static int[] receiveIntArray(Delimiter delimiter) {
        String[] inputs = nextLine().split(delimiter.getRegex());
        int[] ret = new int[inputs.length];
        for (int i = 0; i < inputs.length; i++) {
            ret[i] = Integer.parseInt(inputs[i]);
        }
        return ret;
    }

    static int[] receiveIntArray(String delimiterString) {
        return receiveIntArray(Delimiter.of(delimiterString));
    }

    static BigInteger[] receiveBigIntegerArray(Delimiter delimiter) {
        String[] inputs = nextLine().split(delimiter.getRegex());
        BigInteger[] ret = new BigInteger[inputs.length];
        for (int i = 0; i < inputs.length; i++) {
            ret[i] = new BigInteger(inputs[i]);
        }
        return ret;
    }

    static BigInteger[] receiveBigIntegerArray(String delimiterString) {
        return receiveBigIntegerArray(Delimiter.of(delimiterString));
    }

    static String[] receiveStringArray(Delimiter delimiter) {
        return nextLine().split(delimiter.getRegex());
    }

    static String[] receiveStringArray(String delimiterString) {
        return receiveStringArray(Delimiter.of(delimiterString));
    }

    static void print(Object obj) {
        pw.print(obj);
    }

    static void printf(String str, Object... obj) {
        pw.printf(str, obj);
    }

    static void println(Object obj) {
        pw.println(obj);
    }

    static void println(Object... objs) {
        for (Object obj : objs) {
            println(obj);
        }
    }

    static void flush() {
        pw.flush();
    }
}


Compiler output:
a.cc:1:1: error: 'import' does not name a type
    1 | import java.io.*;
      | ^~~~~~
a.cc:1:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:2:1: error: 'import' does not name a type
    2 | import java.math.*;
      | ^~~~~~
a.cc:2:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:3:1: error: 'import' does not name a type
    3 | import java.util.*;
      | ^~~~~~
a.cc:3:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:4:1: error: 'import' does not name a type
    4 | import java.util.stream.*;
      | ^~~~~~
a.cc:4:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:7:11: error: expected ':' before 'static'
    7 |     public static void main(String[] args) {
      |           ^~~~~~~
      |           :
a.cc:7:29: error: 'String' has not been declared
    7 |     public static void main(String[] args) {
      |                             ^~~~~~
a.cc:7:38: error: expected ',' or '...' before 'args'
    7 |     public static void main(String[] args) {
      |                                      ^~~~
a.cc:17:2: error: expected ';' after class definition
   17 | }
      |  ^
      |  ;
a.cc: In static member function 'static void Main::main(int*)':
a.cc:9:9: error: 'Stdin' was not declared in this scope
    9 |         Stdin.flush();
      |         ^~~~~
a.cc: In static member function 'static void Main::solve()':
a.cc:13:13: error: structured binding declaration cannot have type 'char'
   13 |         char[] input = Stdin.receiveCharArray();
      |             ^~
a.cc:13:13: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:13:13: error: empty structured binding declaration
a.cc:13:16: error: expected initializer before 'input'
   13 |         char[] input = Stdin.receiveCharArray();
      |                ^~~~~
a.cc:14:9: error: 'Stdin' was not declared in this scope
   14 |         Stdin.println(input[2] == input[3] && input[4] == input[5] ? "Yes" : "No");
      |         ^~~~~
a.cc:14:23: error: 'input' was not declared in this scope; did you mean 'int'?
   14 |         Stdin.println(input[2] == input[3] && input[4] == input[5] ? "Yes" : "No");
      |                       ^~~~~
      |                       int
a.cc: At global scope:
a.cc:20:12: error: 'final' does not name a type
   20 |     static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      |            ^~~~~
a.cc:21:12: error: 'final' does not name a type
   21 |     static final PrintWriter pw = new PrintWriter(System.out);
      |            ^~~~~
a.cc:23:11: error: expected ':' before 'enum'
   23 |     public enum Delimiter {
      |           ^~~~~
      |           :
a.cc:24:13: error: expected '}' before '(' token
   24 |         NONE(""), SPACE(" "), DOT("\\."), COMMA(",");
      |             ^
a.cc:23:27: note: to match this '{'
   23 |     public enum Delimiter {
      |                           ^
a.cc:24:14: error: expected unqualified-id before string constant
   24 |         NONE(""), SPACE(" "), DOT("\\."), COMMA(",");
      |              ^~
a.cc:24:14: error: expected ')' before string constant
   24 |         NONE(""), SPACE(" "), DOT("\\."), COMMA(",");
      |             ~^~
      |              )
a.cc:26:16: error: expected ':' before 'String'
   26 |         private String regex;
      |                ^~~~~~~
      |                :
a.cc:26:17: error: 'String' does not name a type; did you mean 'Stdin'?
   26 |         private String regex;
      |                 ^~~~~~
      |                 Stdin
a.cc:28:16: error: expected ':' before 'Delimiter'
   28 |         private Delimiter(String regex) {
      |                ^~~~~~~~~~
      |                :
a.cc:28:33: error: expected ')' before 'regex'
   28 |         private Delimiter(String regex) {
      |                          ~      ^~~~~~
      |                                 )
a.cc:32:15: error: expected ':' before 'static'
   32 |         public static Delimiter of(String input) {
      |               ^~~~~~~
      |               :
a.cc:32:36: error: 'String' has not been declared
   32 |         public static Delimiter of(String input) {
      |                                    ^~~~~~
a.cc:40:15: error: expected ':' before 'String'
   40 |         public String getRegex() {
      |               ^~~~~~~
      |               :
a.cc:40:16: error: 'String' does not name a type; did you mean 'Stdin'?
   40 |         public String getRegex() {
      |                ^~~~~~
      |                Stdin
a.cc: In static member function 'static Stdin::Delimiter Stdin::of(int)':
a.cc:34:33: error: expected primary-expression before '.' token
   34 |                 return Delimiter.valueOf(input.toUpperCase());
      |                                 ^
a.cc:34:48: error: request for member 'toUpperCase' in 'input', which is of non-class type 'int'
   34 |                 return Delimiter.valueOf(input.toUpperCase());
      |                                                ^~~~~~~~~~~
a.cc:35:22: error: 'IllegalArgumentException' does not name a type
   35 |             } catch (IllegalArgumentException e) {
      |                      ^~~~~~~~~~~~~~~~~~~~~~~~
a.cc:36:24: error: 'Arrays' was not declared in this scope
   36 |                 return Arrays.stream(values()).filter(d -> d.getRegex().equals(input)).findFirst().orElse(SPACE);
      |                        ^~~~~~
a.cc:36:38: error: 'values' was not declared in this scope
   36 |                 return Arrays.stream(values()).filter(d -> d.getRegex().equals(input)).findFirst().orElse(SPACE);
      |                                      ^~~~~~
a.cc:36:55: error: 'd' was not declared in this scope
   36 |                 return Arrays.stream(values()).filter(d -> d.getRegex().equals(input)).findFirst().orElse(SPACE);
      |                                                       ^
a.cc:36:107: error: 'SPACE' was not declared in this scope
   36 |                 return Arrays.stream(values()).filter(d -> d.getRegex().equals(input)).findFirst().orElse(SPACE);
      |                                                                                                           ^~~~~
a.cc: At global scope:
a.cc:45:19: error: expected initializer before 'nextLine'
   45 |     static String nextLine() {
      |                   ^~~~~~~~
a.cc: In function 'int receiveInt()':
a.cc:54:16: error: 'Integer' was not declared in this scope
   54 |         return Integer.parseInt(nextLine());
      |                ^~~~~~~
a.cc:54:33: error: 'nextLine' was not declared in this scope
   54 |         return Integer.parseInt(nextLine());
      |                                 ^~~~~~~~
a.cc: At global scope:
a.cc:57:12: error: 'BigInteger' does not name a type
   57 |     static BigInteger receiveBigInteger() {
      |            ^~~~~~~~~~
a.cc: In function 'char receiveChar()':
a.cc:62:16: error: 'nextLine' was not declared in this scope
   62 |         return nextLine().charAt(0);
      |                ^~~~~~~~
a.cc: At global scope:
a.cc:65:16: warning: structured binding declaration can be 'static' only in '-std=c++20' or '-std=gnu++20' [-Wc++20-extensions]
   65 |     static char[] receiveCharArray() {
      |                ^~
a.cc:65:16: error: structured binding declaration cannot have type 'char'
a.cc:65:16: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:65:16: error: empty structured binding declaration
a.cc:65:19: error: expected initializer before 'receiveCharArray'
   65 |     static char[] receiveCharArray() {
      |                   ^~~~~~~~~~~~~~~~
a.cc:69:15: warning: structured binding declaration can be 'static' only in '-std=c++20' or '-std=gnu++20' [-Wc++20-extensions]
   69 |     static int[] receiveIntArray(Delimiter delimiter) {
      |               ^~
a.cc:69:15: error: structured binding declaration cannot have type 'int'
a.cc:69:15: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:69:15: error: empty structured binding declaration
a.cc:69:18: error: expected initializer before 'receiveIntArray'
   69 |     static int[] receiveIntArray(Delimiter delimiter) {
      |                  ^~~~~~~~~~~~~~~
a.cc:78:15: warning: structured binding declaration can be 'static' only in '-std=c++20' or '-std=gnu++20' [-Wc++20-extensions]
   78 |     static int[] receiveIntArray(String delimiterString) {
      |               ^~
a.cc:78:15: error: structured binding declaration cannot have type 'int'
a.cc:78:15: note: type must be cv-qualified 'auto' or reference to cv-qualified 'auto'
a.cc:78:15: error: empty structured binding declaration
a.cc:78:18: error: expected initializer before 'receiveIntArray'
   78 |     static int[] receiveIntArray(String delimiterString) {
      |                  ^~~~~~~~~~~~~~~
a.cc:82:12: error: 'BigInteger' does not name a type
   82 |     static BigInteger[] receiveBigIntegerArray(Delimiter delimiter) {
      |            ^~~~~~~~~~
a.cc:91:12: error: 'BigInteger' does not name a type
   91 |     static BigInteger[] receiveBigIntegerArray(String delimiterString) {
      |            ^~~~~~~~~~
a.cc:95:12: error: 'String' does not name a type; did you mean 'Stdin'?
   95 |     static String[] receiveStringArray(Delimiter delimiter) {
      |            ^~~~~~
      |            Stdin
a.cc:99:12: error: 'String' does not name a type; did you mean 'Stdin'?
   99 |     static String[] receiveStringArray(String delimiterString) {
      |            ^~~~~~
      |            Stdin
a.cc:103:17: error: variable or field 'print' declared void
  103 |     static void print(Object obj) {
      |                 ^~~~~
a.cc:103:23: error: 'Object' was not declared in this scope
  103 |     static void print(Object obj) {
      |                       ^~~~~~
a.cc:107:17: error: variable or field 'printf' declared void
  107 |     static void printf(String str, Object... obj) {
      |                 ^~~~~~
a.cc:107:24: error: 'String' was not declared in this scope; did you mean 'Stdin'?
  107 |     static void printf(String str, Object... obj) {
      |                        ^~~~~~
      |                        Stdin
a.cc:107:36