2020-08-23

import java.util.*;

import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        LinkedHashMap<Integer,Integer> list  = new LinkedHashMap<>();

        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        if(s.length()==0){
            System.out.println(0);
            return;
        }
        char[] c = s.toCharArray();
        String taget = "Good";
        List<Character> list = new LinkedList<Character>();
        for(char ch:c){
            list.add(ch);
        }
        int[] map = new int[list.size()];
        boolean flag = true;
        int count =0;
        while(flag){
            flag = false;
            int index = 0;
            List<Integer> temp = new ArrayList<>();
            for(int i=0;i<list.size()&&index<4;i++){
                if(list.get(i)==taget.charAt(index)&&map[i]==0){
                    temp.add(i);
                    index++;
                }
            }
            if(index==4){
                flag = true;
                count++;
                clear(map,temp);
            }
        }
        System.out.println(count);

    }

    public static void clear(int[] list, List<Integer> temp){
        for(Integer index:temp){
            list[index]=1;
        }
    }
}

class LRU{
    class Node{
        int k;
        int val;
        Node pre;
        Node next;
        public Node(int k, int v){
            this.val = v;
            this.k = k;
        }
        public Node(){}
    }
    private HashMap<Integer,Node> map = new HashMap<>();
    private int size=0;
    private int cap;
    Node head,tail;
    public LRU(int c){
        this.cap = c;
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.pre=head;
    }

    public void put(int k,int v){
        Node node = map.get(k);
        if(node==null){
            Node cur = new Node(k,v);
            map.put(k,cur);
            addNodeHead(cur);
            size++;
            if(size>cap){
                Node n=removeTail();
                map.remove(n.k);
                size--;
            }
        }else{
            node.val = v;
            removeHead(node);
        }
    }
    public Node get(int k){
        Node node = map.get(k);
        if(node!=null)removeHead(node);
        return node;
    }

    private void removeHead(Node node) {
        removeNode(node);
        addNodeHead(node);
    }

    private void addNodeHead(Node cur) {
        cur.next = head.next;
        head.next = cur;
    }

    private Node removeTail() {
        Node cur = tail.pre;
        removeNode(cur);
        return cur;
    }

    private void removeNode(Node cur) {
        Node p = cur.pre;
        Node n = cur.next;
        p.next = n;
        n.pre = p;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Single{

    private Single(){}
    public static class Ins{
        private static final Single instance = new Single();

    }
    public Single getInstance(){
        return Ins.instance;
    }
}

class sort{
    public void Mao(int[] array){
        int n = array.length;
        for(int i=0;i<n-1;i++){
            for(int j=0;j<n-i-1;j++){
                if(array[j+1]<array[j]){
                    swap(j+1,j,array);
                }
            }
        }
    }
    public void select(int[] array){
        int n = array.length;
        for(int i=0;i<n;i++){
            int index = 0;
            for(int j=0;j<n-i;j++){
                if(array[j]>array[index]){
                    index = j;
                }
            }
            swap(index,n-i,array);
        }
    }
    public void insert(int[] array){
        int n = array.length;
        for(int i=1;i<n;i++){
            int j=i;
            while(j>0&&array[j]<array[j-1]){
                swap(j,j-1,array);
                j--;
            }
        }
    }
    public void shell(int[] array){
        int n = array.length;
        int k=n/2;
        while(k!=0){
            for(int i=k;i<n;i++){
                int j=i;
                while(j>=k&&array[j]<array[j-k]){
                    swap(j,j-k,array);
                    j = j-k;
                }
            }
            k = k/2;
        }
    }
    public void gui(int[] array,int l,int r){
        if(l<=r)return;
        int mid = l+(r-l)/2;
        gui(array,l,mid);
        gui(array,mid+1,r);
        merge(array,l,mid,r);
    }

    private void merge(int[] array, int l, int mid, int r) {
        int[] copy = Arrays.copyOfRange(array,l,array.length);
        int temp = mid+1;
        for(int i=l;i<=r;i++){
            if(l>mid){
                array[i]=copy[temp];
                temp++;
            }else if(temp>r){
                array[i]=copy[l];
                l++;
            }else if(array[l]<=array[temp]){
                array[i]=array[l];
                l++;
            }else{
                array[i]=array[temp];
                temp++;
            }
        }
    }

    public void fast(int[] array,int l,int r){
        if(l<r) {
            int temp=qSort(array,l,r);
            fast(array,l,temp-1);
            fast(array,temp+1,r);
        }
    }

    private int qSort(int[] array, int l, int r) {
        int temp = array[l];
        while(l<r){
            while(l<r&&array[r]>temp)r--;
            if(l<r){
                array[l++]=array[r];
            }
            while(l<r&&array[l]<temp){
                l++;
            }
            if(l<r){
                array[r--]=array[l];
            }
        }
        array[l] = temp;
        return l;
    }


    public void swap(int i,int j,int[] array)
    {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}