I don't understand how to use Car AI in Standard Assets.

Ok, I have downloaded the Standard Assets for Unity 5 and I don't understand how the Car AI really works. True, I have solved some irritating issues in the past few hours :(. For example, I put a Waypoint Circuit script to my Waypoint Target Object and put it outside of the parent, allowing it to break prefab instance or whatever its called. Then, I clicked assign using all children. I see some sort of yellow curve and I put way points where I want the car to go to . The curve is weird and is some of it is hanging on the open void. What does this curve even do? How ever some is on the floor. I can't post a screenshot now because my computer is acting weird so I am trying my best to describe it. Anyways, when I start the game, the car ai goes into a completely random direction(not towards the curve) and drives off the road. Also, this beautiful message in the console shows:

Look rotation viewing vector is zero UnityEngine.Quaternion:LookRotation(Vector3) UnityStandardAssets.Utility.WaypointProgressTracker:Update() (at Assets/Standard/Standard Assets/Utility/WaypointProgressTracker.cs:98)

Also, here is some code that I think may contain the error.

 using System;
 using UnityEngine;
 
 namespace UnityStandardAssets.Utility
 {
     public class WaypointProgressTracker : MonoBehaviour
     {
         // This script can be used with any object that is supposed to follow a
         // route marked out by waypoints.
 
         // This script manages the amount to look ahead along the route,
         // and keeps track of progress and laps.
 
         [SerializeField] private WaypointCircuit circuit; // A reference to the waypoint-based route we should follow
 
         [SerializeField] private float lookAheadForTargetOffset = 5;
         // The offset ahead along the route that the we will aim for
 
         [SerializeField] private float lookAheadForTargetFactor = .1f;
         // A multiplier adding distance ahead along the route to aim for, based on current speed
 
         [SerializeField] private float lookAheadForSpeedOffset = 10;
         // The offset ahead only the route for speed adjustments (applied as the rotation of the waypoint target transform)
 
         [SerializeField] private float lookAheadForSpeedFactor = .2f;
         // A multiplier adding distance ahead along the route for speed adjustments
 
         [SerializeField] private ProgressStyle progressStyle = ProgressStyle.SmoothAlongRoute;
         // whether to update the position smoothly along the route (good for curved paths) or just when we reach each waypoint.
 
         [SerializeField] private float pointToPointThreshold = 4;
         // proximity to waypoint which must be reached to switch target to next waypoint : only used in PointToPoint mode.
 
         public enum ProgressStyle
         {
             SmoothAlongRoute,
             PointToPoint,
         }
 
         // these are public, readable by other objects - i.e. for an AI to know where to head!
         public WaypointCircuit.RoutePoint targetPoint { get; private set; }
         public WaypointCircuit.RoutePoint speedPoint { get; private set; }
         public WaypointCircuit.RoutePoint progressPoint { get; private set; }
 
         public Transform target;
 
         private float progressDistance; // The progress round the route, used in smooth mode.
         private int progressNum; // the current waypoint number, used in point-to-point mode.
         private Vector3 lastPosition; // Used to calculate current speed (since we may not have a rigidbody component)
         private float speed; // current speed of this object (calculated from delta since last frame)
 
         // setup script properties
         private void Start()
         {
             // we use a transform to represent the point to aim for, and the point which
             // is considered for upcoming changes-of-speed. This allows this component
             // to communicate this information to the AI without requiring further dependencies.
 
             // You can manually create a transform and assign it to this component *and* the AI,
             // then this component will update it, and the AI can read it.
             if (target == null)
             {
                 target = new GameObject(name + " Waypoint Target").transform;
             }
 
             Reset();
         }
 
 
         // reset the object to sensible values
         public void Reset()
         {
             progressDistance = 0;
             progressNum = 0;
             if (progressStyle == ProgressStyle.PointToPoint)
             {
                 target.position = circuit.Waypoints[progressNum].position;
                 target.rotation = circuit.Waypoints[progressNum].rotation;
             }
         }
 
 
         private void Update()
         {
             if (progressStyle == ProgressStyle.SmoothAlongRoute)
             {
                 // determine the position we should currently be aiming for
                 // (this is different to the current progress position, it is a a certain amount ahead along the route)
                 // we use lerp as a simple way of smoothing out the speed over time.
                 if (Time.deltaTime > 0)
                 {
                     speed = Mathf.Lerp(speed, (lastPosition - transform.position).magnitude/Time.deltaTime,
                                        Time.deltaTime);
                 }
                 target.position =
                     circuit.GetRoutePoint(progressDistance + lookAheadForTargetOffset + lookAheadForTargetFactor*speed)
                            .position;
                 target.rotation =
                     Quaternion.LookRotation(
                         circuit.GetRoutePoint(progressDistance + lookAheadForSpeedOffset + lookAheadForSpeedFactor*speed)
                                .direction);
 
 
                 // get our current progress along the route
                 progressPoint = circuit.GetRoutePoint(progressDistance);
                 Vector3 progressDelta = progressPoint.position - transform.position;
                 if (Vector3.Dot(progressDelta, progressPoint.direction) < 0)
                 {
                     progressDistance += progressDelta.magnitude*0.5f;
                 }
 
                 lastPosition = transform.position;
             }
             else
             {
                 // point to point mode. Just increase the waypoint if we're close enough:
 
                 Vector3 targetDelta = target.position - transform.position;
                 if (targetDelta.magnitude < pointToPointThreshold)
                 {
                     progressNum = (progressNum + 1)%circuit.Waypoints.Length;
                 }
 
 
                 target.position = circuit.Waypoints[progressNum].position;
                 target.rotation = circuit.Waypoints[progressNum].rotation;
 
                 // get our current progress along the route
                 progressPoint = circuit.GetRoutePoint(progressDistance);
                 Vector3 progressDelta = progressPoint.position - transform.position;
                 if (Vector3.Dot(progressDelta, progressPoint.direction) < 0)
                 {
                     progressDistance += progressDelta.magnitude;
                 }
                 lastPosition = transform.position;
             }
         }
 
 
 }
 

I shortened the code down a bit, but didn't shorten it too much in fear that I might accidently not show you some code that might be relevant.

In brief, I really really need a tutorial on how to use the Car AI in the standard assets. Please provide information on how to use it or provide links to a tutorial. Cheers.