import java.util.*;

public class vending_font
{
   public static void main(String[] args)
   {
      new vending_font(new Scanner(System.in));
   }

   public vending_font(Scanner in)
   {
      int N = in.nextInt();
      Snack[] snack = new Snack[N];
      for (int i=0; i<N; i++)
         snack[i] = new Snack(in);
      for (int i=0; i<N; i++)
         snack[snack[i].next].addBuyer(snack[i]);
      for (int i=0; i<N; i++)
         Collections.sort(snack[i].buyers);

      // Greedily buy all the snacks with a profit. Do this
      // until only one snack remains in each cell. There is
      // no consequence to doing this step.
      long res = 0;
      for (int i=0; i<N; i++)
      {
         Snack bestBuyer = snack[i].getBestBuyer();
         if (bestBuyer != null)
         {
            long numTimes = snack[i].numSnacks-1;
            snack[i].numSnacks = 1;
            res += numTimes*bestBuyer.profit;
         }
      }

      // Now our moves have consequences. If we buy only using our optimal
      // buyer then we may have a cycle. Consider the graph of only
      // optimal buyers. Each node has out degree at most 1 and in degree at
      // most 1. Two types of components are allowed in such a graph. A directed
      // line graph or a directed cycle. The directed line case can be resolved
      // in a greedy manner. The cycles are problematic.
      // 
      // There are two options to resolve a cycle:
      // 1) Find some node to not buy, then the graph becomes a line graph.
      //    Follow the topological order of this graph and buy the remaining.
      // 2) Use the second best buyer! This will turn the graph into a directed
      //    line graph. (Either joining our line to another line or isolated node)
      //
      // For a cycle, we find the node where making one of the above choices
      // net's us the optimal reward. For all the line graphs, simply take all
      // the rewards as they are always possible using the topological ordering.

      // Step 1: Find all the cycles!
      ArrayDeque<Snack> stk = new ArrayDeque<Snack>();
      for (int i=0; i<N; i++)
      {
         // Skip isolated nodes!
         if (snack[i].buyers.size() == 0) continue;

         // Skip seen nodes!
         if (snack[i].seen) continue;
         
         // Run through the graph and extract the cycle if available.
         stk.push(snack[i]);
         snack[i].seen = true;
         Snack curSnack = snack[i].getBestBuyer();
         while (curSnack != snack[i] && curSnack != null && !curSnack.seen)
         {
            curSnack.seen = true;
            stk.push(curSnack);   
            curSnack = curSnack.getBestBuyer();
         }
        
         if (curSnack != snack[i])
         {
            // Not a cycle! Use all the primary buyers!
            while (stk.size() > 0)
            {
               Snack bestBuyer = stk.pop().getBestBuyer();
               if (bestBuyer != null)
                  res += bestBuyer.profit;
            }
         }
         else if (stk.size() == 1)
         {
            // Special case, the vending machine works correctly for this snack.
            // For this special case of cycle, we can take everything.
            curSnack = stk.pop();
            res += curSnack.profit;
         }
         else
         {
            // We have a cycle. Find the best decision for resolving
            // the cycle in the graph. Note, if we can find a second buyer
            // it is always better than skipping our node. But a second buyer's
            // existance in the cycle is not always the best option for
            // resolving the cycle. It may be better to skip a low reward.
            // 
            // Obtain the maximimum reward if we didn't have to pay our
            // penalty for taking everything in this cycle.
            //
            // Our reward is given by this equation:
            // reward = maxReward - minPenalty
            long maxReward = 0;
            long minPenalty = Long.MAX_VALUE;
            for (Snack cycleSnack : stk)
            {
               maxReward += cycleSnack.profit;
               int penalty = cycleSnack.getBestBuyer().profit;
               Snack secondBuyer = cycleSnack.getSecondBestBuyer();
               if (secondBuyer != null)
                  penalty -= secondBuyer.profit;
               minPenalty = Math.min(minPenalty, penalty);
            }
            res += maxReward-minPenalty;
            stk.clear();
         }
      }

      // Print the optimal answer.
      System.out.println(res);
   }

   class Snack implements Comparable<Snack>
   {
      int next, buyPrice, sellPrice, numSnacks, profit;
      ArrayList<Snack> buyers;
      boolean seen;

      public Snack(Scanner in)
      {
         next = in.nextInt()-1;
         buyPrice = in.nextInt();
         sellPrice = in.nextInt();
         numSnacks = in.nextInt();
         profit = -1;
         buyers = new ArrayList<Snack>();
         seen = false;
      }
   
      // Add this buyer to our list of button presses that can
      // buy this snack.
      void addBuyer(Snack rhs)
      {
         rhs.profit = sellPrice - rhs.buyPrice;
         // Only add this buyer if they make a profit.
         if (rhs.profit > 0)
            buyers.add(rhs);
      }

      Snack getBestBuyer()
      {
         if (buyers.size() < 1) return null;
         return buyers.get(0);
      }

      Snack getSecondBestBuyer()
      {
         if (buyers.size() < 2) return null;
         return buyers.get(1);
      }

      public int compareTo(Snack rhs)
      {
         return rhs.profit - profit;
      }
   }
}