require 'base64'
alphabet = [*'A'..'Z'] + [*'a'..'z']
strs = []
for a in alphabet
  for b in alphabet
    for c in alphabet
      strs << Base64.encode64(a + b + c).split.join
      strs << Base64.encode64(a + b).split.join
      strs << Base64.encode64(a).split.join
    end
  end
end
strs = strs.sort.uniq
b64chars = alphabet + [*'0'..'9'] + %W(+ /)
b64chars.sort.each do |c|
  next if strs.select{|a| a[0] == c}.count > 1
  next if strs.select{|a| a[1] == c}.count > 1
  next if strs.select{|a| a[2] == c}.count > 1
  next if strs.select{|a| a[3] == c}.count > 1
  print c
end

require 'capybara'
require 'capybara/poltergeist'
require 'rmagick'
include Magick

def solve(src)
  img = ImageList.new('hoge.png')
  w = img.rows
  h = img.columns
  cnt = Hash.new{0}
  w.times do |x|
    h.times do |y|
      p = img.pixel_color(x,y)
      r, g, b = p.red / 257, p.green / 257, p.blue / 257
      next if r== 255 && g==255 && b==255
      cnt[[r,g,b]] += 1
    end
  end
  target = cnt.to_a.sort_by{|a,b|b}[0][0]
  minx = 999999
  maxx = 0
  miny = 999999
  maxy = 0
  w.times do |x|
    h.times do |y|
      p = img.pixel_color(x,y)
      r, g, b = p.red / 257, p.green / 257, p.blue / 257
      if [r,g,b] == target
        minx = [minx, x].min
        maxx = [maxx, x].max
        miny = [miny, y].min
        maxy = [maxy, y].max
      end
    end
  end
  return p([(maxx+minx)/2, (miny+maxy)/2])
end
s = Capybara::Session.new(:poltergeist)
s.visit 'http://ctfquest.trendmicro.co.jp:43210/click_on_the_different_color'
while true
  s.save_screenshot 'hoge.png'
  cur = s.current_path
  s.driver.click *solve(src)
  sleep 1 while cur == s.current_path 
  puts "OK"
end

require 'roman-numerals'
require 'ctf'
require 'numbers_in_words'
require 'numbers_in_words/duck_punch'
TCPSocket.open(*ARGV) do |s|
  s.echo = true
  while true
    input  =s.expect('=')[0].split(/=/)[0].gsub(',','')
    input = input.gsub(/[A-Z]+/) do |t|
      RomanNumerals.to_decimal(t).to_s
    end
    input = input.gsub(/[a-z ]+/) do |t|
      if t.strip == ''
        t
      else
        t.in_numbers.to_s
      end
    end
    puts "Input #{input}"
    s.print eval(input).to_s + "\n"
  end
end

class Node
  attr_accessor :neighbor, :cost, :name, :visited
  attr :type
  def initialize(type)
    @neighbor = []
    @type = type
    @cost = 1
    @visited = false
  end

  def add(node,direction)
    if self.neighbor.include?(node)
      STDERR.puts 'already'
      return
    end
    if direction == 'D'
      self.neighbor <<= [node, ?D]
      node.neighbor <<= [self, ?U]
    else
      self.neighbor <<= [node, ?R]
      node.neighbor <<= [self, ?L]
    end
  end

  def to_s
    "node(#{name}:#{type})"
  end

end
  sum = 0
while gets
  w,h,c = $_.split.map(&:to_i)
  map = Array.new(h){gets.chomp}
  start = nil
  node = Array.new(h){Array.new(w)}
  h.times do |y|
    w.times do |x|
      if map[y][x] == '.'
        node[y][x] = Node.new(:plain)
        start = node[y][x]
      elsif map[y][x] == 'S'
        node[y][x] = Node.new(:start)
      elsif map[y][x] == 'C'
        node[y][x] = Node.new(:check)
      elsif map[y][x] == 'G'
        node[y][x] = Node.new(:goal)
      elsif map[y][x] == 'E'
        node[y][x] = Node.new(:energy)
      end
      if node[y][x]
        node[y][x].name = "Node(#{y},#{x})"
      end
    end
  end
  h.times do |y|
    w.times do |x|
      if node[y][x] && node[y+1][x]
        node[y][x].add(node[y+1][x], 'D')
      end
      if node[y][x] && node[y][x+1]
        node[y][x].add(node[y][x+1], 'R')
      end
    end
  end
  nodes = []
  h.times do |y|
    w.times do |x|
      nodes << node[y][x] if node[y][x]
    end
  end
  while true
    update = false
    nodes.each do |node|
      break if update
      if node.type == :plain
        if node.neighbor.size <= 1
          node.neighbor[0][0].neighbor.reject!{|n,dir| n == node}
          nodes.delete node
          update = true
          break
        end
        if node.neighbor.size == 2
          node.neighbor.each do |n2,dir|
            next if n2.type != :plain
            next if n2.neighbor.size != 2
            # 隣接するノードの
            n2dir = n2.neighbor.select{|n,dir| n == node}[0][1]
            n1dir = dir
            n2.neighbor.reject!{|n,dir| n == node}
            #node.neighbor.reject!{|n,dir| n == n2}
            node.cost += n2.cost
            didir = n2.neighbor[0][0].neighbor.select{|n,dir| n==  n2}[0][1]
            n2.neighbor[0][0].neighbor.reject!{|n,dir| n==  n2}
            n2.neighbor[0][0].neighbor << [node, didir + n2dir]
            node.neighbor.select{|nv,t| nv == n2}[0][1] += n2.neighbor[0][1]
            node.neighbor.select{|nv,t| nv == n2}[0][0] = n2.neighbor[0][0]
            update = true
            break
          end
        end
      end
    end
    break unless update
  end

  nodes.each.with_index do |node,i|
    node.name = i
  end
  require 'pqueue'
  que = PQueue.new{|a,b| a[0] < b[0]}
  start = nodes.select{|a|a.type == :start}[0].name
  que.push([0,start,1 << start])
  dp = {}
  back = {}
  dp[[start, 1<< start]] = 0
  ans = nil
  mask = 0
  nodes.each do |i|
    mask |= 1 << i.name if i.type == :check
  end
  while que.top
    tmp = que.pop
    cost  = tmp[0]
    cur = tmp[1..-1]
    if nodes[cur[0]].type == :goal && (cur[1] & mask) == mask
      str = ''
      until cur == [start,1 << start]
        str = back[cur][0] + str
        cur = back[cur][1]
      end
      puts str
      sum += cost
      break
    end
    next if dp[cur] < cost
    nodes[cur[0]].neighbor.each do |n, dir|
      if (cur[1] >> n.name & 1) == 1
        ncost = cost + n.cost
      else
        ncost = cost
        ncost -= 20 if n.type == :energy
      end
      nvisited = cur[1] | (1 << n.name)
      if dp.key?([n.name, nvisited]) == false || dp[[n.name,nvisited]] > ncost
        dp[[n.name,nvisited]] = ncost
        back[[n.name,nvisited]] = [dir, cur]
        que.push([ncost, n.name, nvisited])
      end
    end
  end
  # require 'gviz'
  # Gviz.new.graph do
  #   nodes.each do |node|
  #     add node.neighbor.map{|a|a[0].name} => node.name
  #     node node.name, label: "#{node.type} #{node.cost} #{node.name}"
  #     node.neighbor.each do |n,dir|
  #       edge "#{node.name}_#{n.name}".to_sym, label: dir
  #     end
  #   end
  #   save :graph, :png
  # end
end
puts sum

rps = File.read('rps.dat').strip # 4500文字程度のRPSからなるランダムな文字列
require 'json'
win = {'R' => 'P', 'P' => 'S' , 'S' => 'R'}
cur = 'PSPPSPPSRSSSRRRRRSSSRRPPSRSSSR'
while true
  clen = cur.size
  res = JSON.load(`curl -s 'http://ctfquest.trendmicro.co.jp:8181/98cd98a1894676b9/bf9b62aa00e7986fa75ef400f06d57e5/ai_rps.py?hands=#{rps}#{cur}R'`)
  p [:fisrt, res['ai_hands'][-1]]
  cur += win[res['ai_hands'][-1]]
  res = JSON.load(`curl -s 'http://ctfquest.trendmicro.co.jp:8181/98cd98a1894676b9/bf9b62aa00e7986fa75ef400f06d57e5/ai_rps.py?hands=#{rps}#{cur}'`)
  h = res['ai_hands'][-(cur.size)..-1]
  p [:hands, res['ai_hands'][-1]]
  p res['consecutive_wins']
  p cur
  if  res['consecutive_wins'] >= 30
    File.write('hoge', res.to_json)
  end
  sleep 10
end