output_description: Print the AtCoDeer's maximum possible score.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      s
attempt: from collections import Counter,defaultdict,deque
  import sys
  import bisect
  import math
  from itertools
  import queue
  import copy
  from scipy import linalg
  import scipy
  import numpy as np
  from heapq import heappop, heappush
  input = sys.stdin.readline
  sys.setrecursionlimit(10**8)
  mod = 10**9+7
  
  def inp(): # n=1
      return int(input())
  def inpm(): # x=1,y=2
      return map(int,input().split())
  def inpl(): # a=[1,2,3,4,5,...,n]
      return list(map(int, input().split()))
  def inpls(): # a=['1','2','3',...,'n']
      return list(input().split())
  def inplm(n): # x=[] 複数行
      return list(int(input()) for _ in range(n))
  def inpll(n): # [[1,1,1,1],[2,2,2,2],[3,3,3,3]]
      return sorted([list(map(int, input().split())) for _ in range(n)])
  def sortx(x,n,k):
      if k == 0:x.sort(key=lambda y:y[1,n])
      else:x.sort(reversed=True, key=lambda y:y[1,n])
  
  def main():
      s = input()
      NG = 1
      NP = 0
      did = ["g"]
      point = 0
      for i in range(1,len(s)):
          if s[i] == "g":
              if NP + 1 <= NG:
                  did.append("p")
                  NP += 1
                  point += 1
              else:
                  did.append("g")
                  NG += 1
          else:
              if NP + 1 <= NG:
                  did.append("p")
                  NP += 1
              else:
                  did.append("g")
                  NG += 1
                  point -= 1
      print(point)
  
  if __name__ == "__main__":
      main()
problem_description: Statement
  
  AtCoDeer the deer and his friend TopCoDeer is playing a game. The game
  consists of N turns. In each turn, each player plays one of the two _gestures_
  , _Rock_ and _Paper_ , as in Rock-paper-scissors, under the following
  condition:
  
  (※) After each turn, (the number of times the player has played Paper)≦(the
  number of times the player has played Rock).
  
  Each player's score is calculated by (the number of turns where the player
  wins) - (the number of turns where the player loses), where the outcome of
  each turn is determined by the rules of Rock-paper-scissors.
  
  _(For those who are not familiar with Rock-paper-scissors: If one player plays
  Rock and the other plays Paper, the latter player will win and the former
  player will lose. If both players play the same gesture, the round is a tie
  and neither player will win nor lose.)_
  
  With his supernatural power, AtCoDeer was able to foresee the gesture that
  TopCoDeer will play in each of the N turns, before the game starts. Plan
  AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
  
  The gesture that TopCoDeer will play in each turn is given by a string s. If
  the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th
  turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will
  play Paper in the i-th turn.
samples: [{"input": "gpg", "output": "0\n    \n\nPlaying the same gesture as the opponent in each turn results in the score of\n0, which is the maximum possible score.\n\n* * *"}, {"input": "ggppgggpgg", "output": "2\n    \n\nFor example, consider playing gestures in the following order: Rock, Paper,\nRock, Paper, Rock, Rock, Paper, Paper, Rock, Paper. This strategy earns three\nvictories and suffers one defeat, resulting in the score of 2, which is the\nmaximum possible score."}]