program tieses_;
  { 27 u‘davinys }
  const MAX = 6; { maksimalus susikirtim— skai‡ius }
        N = 4; { maksimalus tiesi— skai‡ius }
  type tiese = record
                  a, b : integer;
                end;
       tieses = array [1..N] of tiese;
       susikirt = array [1..MAX] of record
                                      nr1, nr2 : integer; { kurios tieses kertasi }
                                      x, y : real; { koordinat‚s }
                                      prikl : boolean;
                                      { ar priklauso keturkampiui }
                                    end;
        aibe = set of 1..4;

  function lyg (t1, t2 : tiese) : boolean;
    { nustato, ar dvi ties‚s yra lygiagre‡ios }
  begin
    lyg := t1.a = t2.a
  end;

  procedure kertasi (t : tieses; { ties‚s }
                     i, j : integer; { j— numeriai }
                     var s : susikirt; { susikirtimo tažk— lentel‚ }
                     var sk : integer { j— skai‡ius });
    { randa tiesi— i ir j susikirtimo tažk… }
    const eps = 0.00000001;
    var buvo : boolean;
  begin
    if t[i].a <> t[j].a  { jei ties‚s nelygigagre‡ios }
       then begin
              sk := sk + 1;
              s[sk].nr1 := i;
              s[sk].nr2 := j;
              s[sk].prikl := false;
              s[sk].x := (t[j].b - t[i].b) / (t[i].a - t[j].a);
              s[sk].y := (t[i].a * t[j].b - t[j].a * t[i].b)/(t[i].a - t[j].a);
              { tikrinsime, ar tokio tažko nebuvo }
              buvo := false;
              for i := 1 to sk - 1 do
                if (abs (s[i].x - s[sk].x) < eps) and
                   (abs (s[i].y - s[sk].y) < eps)
                   then buvo := true;
               if buvo then
                  sk := sk - 1;
             end;
  end;

  function vidurinis (s : susikirt; a, b, c : integer) : boolean;
    { patikrina, ar tažkas b yra tarp tažk— a ir c, kai }
    { ‘inoma, kad tie tažkai tikrai yra vienoje ties‚je }
  begin
    vidurinis := (s[a].x <= s[b].x) and (s[b].x <= s[c].x) and
                 (s[a].y <= s[b].y) and (s[b].y <= s[c].y) or
                 (s[c].x <= s[b].x) and (s[b].x <= s[a].x) and
                 (s[c].y <= s[b].y) and (s[b].y <= s[a].y)
  end;

  function v_tiese (s : susikirt; i, j : integer) : boolean;
    { patikrina, ar susikirtimo tažkai i ir j yra vienoje ties‚je }
  begin
    v_tiese := (s[i].nr1 = s[j].nr1) or (s[i].nr1 = s[j].nr2) or
             (s[i].nr2 = s[j].nr1) or (s[i].nr2 = s[j].nr2)
  end;

  procedure penki (t : tieses;
                   var s : susikirt; { susikirtimo tažkai }
                   sk : integer; { j— skai‡ius }
                   var sudaro : boolean);
    { randa keturkampio tažkus, kai ties‚s kertasi penkiuose tažkuose }
     var k : array [1..N] of integer; { kiek tažk— kerta i-t…j… tiesŠ }
         i, j, nm : integer;
         vid : boolean;
  begin
    {  keturkamp traukiame lygiagre‡i— tiesi— tažkus }
    for i := 1 to N do
      k[i] := 0;
    for i := 1 to sk do
      begin
        k[s[i].nr1] := k[s[i].nr1] + 1;
        k[s[i].nr2] := k[s[i].nr2] + 1;
      end;
    for i := 1 to sk do
      if k[s[i].nr1] = 2
         then s[i].prikl := true
         else nm := i; { penktojo tažko numeris }
    { tikriname, ar tinka penktasis }
    { t. y. ar jis n‚ra viduryje tarp kuri— nors dviej— tažk— }
    vid := false;
    for i := 1 to sk do
     for j := i + 1 to sk do
       if (i <> nm) and (j <> nm) and
          v_tiese (s, i, j) and v_tiese (s, i, nm)
          { jei visi trys tažkai yra vienoje ties‚je }
          and vidurinis (s, i, nm, j)
              then vid := true;
     sudaro := not vid;
  end;


  procedure vid (var s : susikirt; sk, i : integer;
                 var aib : aibe);
    { randa i-tosios ties‚s vidurinj susikirtimo tažk… }
    { ir j traukia  keturkamp }
    var num : array [1..3] of integer;
    k, j, nm : integer;
  begin
    k := 1;  j := 0;
    while j < 3 do { surandame visus tris i-tosios ties‚s susikirtimo }
      begin        { tažkus }
        if (s[k].nr1 = i) or (s[k].nr2 = i)
           then begin
                  j := j + 1;
                  num[j] := k;
                end;
         k := k + 1;
      end;
    if vidurinis (s, num[1], num[2], num[3])
       then nm := num[2]
       else if vidurinis (s, num[2], num[1], num[3])
               then nm := num[1]
               else nm := num[3];
    { tažk… trauksime  keturkamp }
    s[nm].prikl :=  true;
    if s[nm].nr1 in aib
       then aib := aib - [s[nm].nr1]
       else aib := aib + [s[nm].nr1];
    if s[nm].nr2 in aib
       then aib := aib - [s[nm].nr2]
       else aib := aib + [s[nm].nr2];
  end;

  procedure sesi (t : tieses;
                   var s : susikirt; { susikirtimo tažkai }
                   sk : integer { j— skai‡ius });
    { randa keturkampio tažkus, kai ties‚s kertasi žežiuose tažkuose }
    var aib : aibe;
        i : integer;
  begin
    aib := [];
    { rasime trij— tiesi— vidurinius tažkus ir juos jungsime  keturkamp }
    vid (s, sk, 1, aib);
    vid (s, sk, 2, aib);
    vid (s, sk, 3, aib);
    { rasime ketvirt… tažk… }
    for i := 1 to sk do
      if not s[i].prikl and (s[i].nr1 in aib) and (s[i].nr2 in aib)
         then s[i].prikl := true
  end;

  procedure keturkampis (t : tieses; { duotosios ties‚s }
                         var s : susikirt; { keturkampio virž–ni— koordinat‚s }
                         var sudaro : boolean; { ar sudaro keturkamp }
                         var sk : integer { susikirtimo tažk— skai‡ius });
    var i, j : integer;
  begin
    { rasime visus tiesi— tarpusavio susikirtimo tažkus }
    sk := 0;
    for i := 1 to N do
      for j := i + 1 to N do
        kertasi (t, i, j, s, sk);
    case sk of
      0, 1, 2, 3 : sudaro := false;
      4 : begin
            sudaro := lyg (t[1], t[2]) or lyg (t[1], t[3]) or lyg (t[1], t[4]);
            if sudaro
               then for i := 1 to sk do
                      s[i].prikl := true;
           end;
      5 : penki (t, s, sk, sudaro);
      6 : begin
            sudaro := true;
            sesi (t, s, sk);
          end;
     end;
  end;

  var f : text;
      i, sk : integer;
      sudaro : boolean;
      t : tieses;
      s : susikirt;
begin
  assign (f, 'TIESES.DAT');
  reset (f);
  for i := 1 to N do
    read (t[i].a, t[i].b);
  close (f);
  keturkampis (t, s, sudaro, sk);
  if not sudaro
     then writeln ('Ne')
     else for i := 1 to sk do
            if s[i].prikl
               then writeln (s[i].x : 3 : 0, s[i].y : 3 : 0)
end.