I personally feel that measuring code complexity based on lines of code is usually unfair. It is a good clue that there is <em>probably</em> some design problem. But I don't think it indicates a problem as a rule.
E.g. What if the structure of the program really was simple - like a huge case statement that had one method call per case. Assume that polymorphism and a single call to a base class method isn't posible in this case. In other words the structure is simple and straight forward, easy to understand - the size is simply 'big'. That isn't always a problem, sometimes things might just be big because that's how it is.
Is it not possible that attempting to divide something up into smaller bits can end up fragmenting what is really a single concept or thought that should have been treated as a unit on it's own. Could it not be elegant despite its size?
I've seen people take forever to get things coded and working because they struggle trying to fit their code to all these "rules of thumb" as if they were laws. Usually they could have a perfectly understandable and working solution that is simple enough to understand and not likely to cause maintenance issues if they would only realize that all the books on their shelf are full of guidelines, not "commandments".