Find a mirror configuration to match laser destinations UPDATED SCORING: As this challenge is more difficult than I anticipated, I have adjusted the scoring. A program that can solve a single mirror input is a valid answer. More sophisticated programs get a bonus to their score.

There have been several puzzles on PPCG to find a laser path in a box of
mirrors. In this puzzle, you need to create a box of mirrors to match a number
of laser destinations. 

You are given a box and a specifications where lasers are to enter and exit.
Your program needs to place exactly N double-sided mirrors in the box to meet
the specification. The mirrors must be angled at 45 degrees but can be forward
sloping or back sloping.

Input

Your program should accept a box grid via STDIN, command line argument, or file
in the following format examples:

+--G--+     +abcde+
G     |     f/////d
|    /|     a//   c
+-----+     f     |
            +-b-e-+


The letter pairs ([a-zA-Z] may be used) indicate the input/output of up to 52 lasers.
Inside the box will be N / mirrors. The box dimensions will be
3 &lt;= W,H &lt;= 200. The box is made of +|- characters. There may be any number of
  mirrors in the box including zero.

Output

The output should match the input, except the / characters may be moved and/or
changed into \ characters.  Your program should send a correct mirror box
string to STDOUT or a file, trailing new line optional. If no placement of
mirrors can meet the input specification, output Impossible\n. Examples of
possible solutions:

+--G--+     +abcde+
G  /  |     f \ \ d
|     |     a/ \  c
+-----+     f / //|
            +-b-e-+


Testing example

Input:

+abcdefghijklmnopqrstuvwxyA-+
|///////////////            |
|///////////////            |
|                           |
+-Abcdefghijklmnopqrstuvwxya+


Example output:

+abcdefghijklmnopqrstuvwxyA-+
|\                         \|
|/                        / |
|\\\\\\\\\\\\\\\\\\\\\\\\\\ |
+-Abcdefghijklmnopqrstuvwxya+


Scoring (UPDATED)

This is code-golf with bonuses. You should nominate with your answer how many mirrors your program can solve (N). Your score is the length of your program in bytes divided by N. This allows people to enter with a simple program, but rewards more ambition programmers with a bonus.

Standard loopholes disallowed.
Python, 671 654 bytes

Not a solution, but an attempt, read below.

import random as R
def V(F):
 for S,_x,_y in (F[0],0,1),(F[-1],0,-1),([L[0] for L in F],1,0),([L[-1] for L in F],-1,0):
  for i,C in enumerate(S):
   if not C in '+-|':
    x=_x;y=_y
    if not x: X=i;Y=y
    elif not y: Y=i;X=x
    while F[Y][X] != C:
     if F[Y][X]=='\\':x,y=y,x
     if F[Y][X]=='/':a=x+y;x,y=x-a,y-a
     X+=x;Y+=y
     try:
      if F[Y][X] in '+-|':return False
     except:
      return False
 return True
F=open(input()).read().split('\n')
while 1:
 _=[F[0]]+['\n'.join([L[0]+''.join([R.choice(' \\/')for i in range(len(F[0])-2)])+L[-1] for L in F[1:-1]])]+[F[-1]]
 if V(_):
  for l in _: print l
  break


I did not golf this to the max, since I'm not satisfied with the solution.
V validates a given solution by walking the field F for each character C it finds on the sideline. Solutions are generated at random. It's ugly, it works for entry1, but takes a Lot of time for the other entries. Since it randomly tries solutions, I don't consider this to be an actual solution for the given problem; but it might help others.

Run:
echo "entry1.txt" | python script.py