Language: C++

import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.complex;
import std.container;
import std.conv;
import std.functional;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

auto readInts() {
	return array(map!(to!int)(readln().strip().split()));
}
auto readInt() {
	return readInts()[0];
}
auto readLongs() {
	return array(map!(to!long)(readln().strip().split()));
}
auto readLong() {
	return readLongs()[0];
}

void readlnTo(T...)(ref T t) {
    auto s = readln().split();
    assert(s.length == t.length);
    foreach(ref ti; t) {
        ti = s[0].to!(typeof(ti));
        s = s[1..$];
    }
}

class UnionFindTree {
public:
    this(size_t n) {
        parent = iota(n).array();
        rank = new size_t[](n);
    }
    size_t find(size_t n) {
        if(n == parent[n]) {
            return n;
        } else {
            parent[n] = find(parent[n]);
            return parent[n];
        }
    }
    void unite(size_t n, size_t m) {
        auto p1 = find(n);
        auto p2 = find(m);
        if(n == m) {
            return;
        }
        if(rank[p1] < rank[p2]) {
            swap(p1, p2);
        }
        if(rank[p1] == rank[p2]) {
            ++rank[p1];
        }
        parent[p2] = p1;
    }
private:
    size_t[] parent;
    size_t[] rank;
}
unittest {
    auto uft = new UnionFindTree(10);
    foreach(i; iota(10)) {
        assert(uft.find(i) == i);
    }
    foreach(i; iota(10).filter!(a => a%3 == 0).drop(1)) {
        uft.unite(i, i-3);
    }
    foreach(i; iota(10).filter!(a => a%3 == 0)) {
        assert(uft.find(0) == uft.find(i));
    }
    foreach(i; iota(10).filter!(a => a%3 != 0)) {
        assert(uft.find(0) != uft.find(i));
    }
}

const real eps = 1e-10;

const long p = 1_000_000_000 + 7;

void main(){
    auto s = readln().chomp();
    writeln(s.canFind("AC")? "Yes": "No");
}



Compiler output:
a.cc:33:15: error: too many decimal points in number
   33 |         s = s[1..$];
      |               ^~~~
a.cc:1:1: error: 'import' does not name a type
    1 | import std.algorithm;
      | ^~~~~~
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 std.array;
      | ^~~~~~
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 std.ascii;
      | ^~~~~~
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 std.bigint;
      | ^~~~~~
a.cc:4:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:5:1: error: 'import' does not name a type
    5 | import std.complex;
      | ^~~~~~
a.cc:5:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:6:1: error: 'import' does not name a type
    6 | import std.container;
      | ^~~~~~
a.cc:6:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:7:1: error: 'import' does not name a type
    7 | import std.conv;
      | ^~~~~~
a.cc:7:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:8:1: error: 'import' does not name a type
    8 | import std.functional;
      | ^~~~~~
a.cc:8:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:9:1: error: 'import' does not name a type
    9 | import std.math;
      | ^~~~~~
a.cc:9:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:10:1: error: 'import' does not name a type
   10 | import std.range;
      | ^~~~~~
a.cc:10:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:11:1: error: 'import' does not name a type
   11 | import std.stdio;
      | ^~~~~~
a.cc:11:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:12:1: error: 'import' does not name a type
   12 | import std.string;
      | ^~~~~~
a.cc:12:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:13:1: error: 'import' does not name a type
   13 | import std.typecons;
      | ^~~~~~
a.cc:13:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc: In function 'auto readInts()':
a.cc:16:22: error: 'map' was not declared in this scope
   16 |         return array(map!(to!int)(readln().strip().split()));
      |                      ^~~
a.cc:16:16: error: 'array' was not declared in this scope
   16 |         return array(map!(to!int)(readln().strip().split()));
      |                ^~~~~
a.cc: In function 'auto readLongs()':
a.cc:22:22: error: 'map' was not declared in this scope
   22 |         return array(map!(to!long)(readln().strip().split()));
      |                      ^~~
a.cc:22:16: error: 'array' was not declared in this scope
   22 |         return array(map!(to!long)(readln().strip().split()));
      |                ^~~~~
a.cc: At global scope:
a.cc:28:6: error: variable or field 'readlnTo' declared void
   28 | void readlnTo(T...)(ref T t) {
      |      ^~~~~~~~
a.cc:28:15: error: 'T' was not declared in this scope
   28 | void readlnTo(T...)(ref T t) {
      |               ^
a.cc:39:5: error: expected unqualified-id before 'this'
   39 |     this(size_t n) {
      |     ^~~~
a.cc:43:5: error: 'size_t' does not name a type
   43 |     size_t find(size_t n) {
      |     ^~~~~~
a.cc:1:1: note: 'size_t' is defined in header '<cstddef>'; this is probably fixable by adding '#include <cstddef>'
  +++ |+#include <cstddef>
    1 | import std.algorithm;
a.cc:51:16: error: 'size_t' has not been declared
   51 |     void unite(size_t n, size_t m) {
      |                ^~~~~~
a.cc:51:26: error: 'size_t' has not been declared
   51 |     void unite(size_t n, size_t m) {
      |                          ^~~~~~
a.cc:66:5: error: 'size_t' does not name a type
   66 |     size_t[] parent;
      |     ^~~~~~
a.cc:66:5: note: 'size_t' is defined in header '<cstddef>'; this is probably fixable by adding '#include <cstddef>'
a.cc:67:5: error: 'size_t' does not name a type
   67 |     size_t[] rank;
      |     ^~~~~~
a.cc:67:5: note: 'size_t' is defined in header '<cstddef>'; this is probably fixable by adding '#include <cstddef>'
a.cc: In member function 'void UnionFindTree::unite(int, int)':
a.cc:52:19: error: 'find' was not declared in this scope
   52 |         auto p1 = find(n);
      |                   ^~~~
a.cc:57:12: error: 'rank' was not declared in this scope
   57 |         if(rank[p1] < rank[p2]) {
      |            ^~~~
a.cc:58:13: error: 'swap' was not declared in this scope
   58 |             swap(p1, p2);
      |             ^~~~
a.cc:60:12: error: 'rank' was not declared in this scope
   60 |         if(rank[p1] == rank[p2]) {
      |            ^~~~
a.cc:63:9: error: 'parent' was not declared in this scope
   63 |         parent[p2] = p1;
      |         ^~~~~~
a.cc: At global scope:
a.cc:70:5: error: expected primary-expression before 'auto'
   70 |     auto uft = new UnionFindTree(10);
      |     ^~~~
a.cc:70:5: error: expected '}' before 'auto'
a.cc:69:10: note: to match this '{'
   69 | unittest {
      |          ^
a.cc:70:5: error: expected ',' or ';' before 'auto'
   70 |     auto uft = new UnionFindTree(10);
      |     ^~~~
a.cc:71:12: error: expected constructor, destructor, or type conversion before '(' token
   71 |     foreach(i; iota(10)) {
      |            ^
a.cc:71:20: error: expected constructor, destructor, or type conversion before '(' token
   71 |     foreach(i; iota(10)) {
      |                    ^
a.cc:74:12: error: expected constructor, destructor, or type conversion before '(' token
   74 |     foreach(i; iota(10).filter!(a => a%3 == 0).drop(1)) {
      |            ^
a.cc:74:20: error: expected constructor, destructor, or type conversion before '(' token
   74 |     foreach(i; iota(10).filter!(a => a%3 == 0).drop(1)) {
      |                    ^
a.cc:77:12: error: expected constructor, destructor, or type conversion before '(' token
   77 |     foreach(i; iota(10).filter!(a => a%3 == 0)) {
      |            ^
a.cc:77:20: error: expected constructor, destructor, or type conversion before '(' token
   77 |     foreach(i; iota(10).filter!(a => a%3 == 0)) {
      |                    ^
a.cc:80:12: error: expected constructor, destructor, or type conversion before '(' token
   80 |     foreach(i; iota(10).filter!(a => a%3 != 0)) {
      |            ^
a.cc:80:20: error: expected constructor, destructor, or type conversion before '(' token
   80 |     foreach(i; iota(10).filter!(a => a%3 != 0)) {
      |                    ^
a.cc:83:1: error: expected declaration before '}' token
   83 | }
      | ^
a.cc:85:7: error: 'real' does not name a type
   85 | const real eps = 1e-10;
      |       ^~~~
a.cc:87:16: error: unable to find numeric literal operator 'operator""_000_000_000'
   87 | const long p = 1_000_000_000 + 7;
      |                ^~~~~~~~~~~~~
a.cc:89:1: error: '::main' must return 'int'
   89 | void main(){
      | ^~~~
a.cc: In function 'int main()':
a.cc:90:14: error: 'readln' was not declared in this scope; did you mean 'readInt'?
   90 |     auto s = readln().chomp();
      |              ^~~~~~
      |              readInt
a.cc:91:5: error: 'writeln' was not declared in this scope
   91 |     writeln(s.canFind("AC")? "Yes": "No");
      |     ^~~~~~~