summaryrefslogblamecommitdiffstats
path: root/po/de.po
blob: 48445456ee3de1760d219d3bb55158d256eaed52 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16















                                                                                                     
                   





                                                        


                                                      

                                                         

                                       
 







                                                                  

         




                                                 



                                                


                           
 


                           
 


                           
 


                           
 


                           
 


                           
 

                           

         


                           
 


                           
 


                           
 


                              
 
                           
           

                                                 
 


                              
 
                            
           

                                     
 
                                                      
           

                                   
 


                                                    
 


                           
 


                                                    
 


                           
 



                           
 
                           
           
                                                           
         
                                                                             
 

                                           
           





                                   
 
                           
           

                                  
 









                                                                          
 
                            
           

                                        
 


                                                     
 
                            
           

                                                                         
 


                            
 


                            
 
                              
           

                                          
 
                              
           

                                    
 









                                                          

         

                                                          

         





















                                                          
 
                              
        

                                             

         


                                                          
 
















































































                                                             
           

                     
 
                                                          
           

                     
 



                                                          
 



                                                          
 



                              
 



                              
 

                              
        

              
         

              
 
                                                          
           
                                                     
         

                                                                
 


                                                          
 
                                                          
           












                                                          

         




                                                            
 
                                                          
           
                          
         
 

                                                          

         

                                                          

         





                                                           
           

                                                      
 


                                                           
 


                                                           
 

                                                           

         


                               
 


                                                            
 

                               

         
                                                            
           

                                  
 


                                                            
         
 


                                                            

         
                                                            
           
                                                        

         

                                                            

         
                                                            
           
                                                

         

                                                            

         



                                                            
 



                                                            
 


                               
 


                                                           

         

                               

         

                                             
         
 







                                
         
 


                                         
         
 


                                                    
         
 




                               
 

                                 
         
 











                               
         
 





                                
 





                                 
           
                              

         
                           
           
                              
         
 
                           
           

                                           
 
                           
           
                                
         
 
                           
           
                                                 

         
                           
           


                                                     

         

                            

         


                            
 
                            
           
                             

         
                            
           

                                            
 
                            
           

                                           
 
                            
           

                                                             
 
                            
           
                                             
         
 

                                    
         
 
                            
           
                                                  

         
                                               
           

                    
 
                            
           
                        

         
                            
           
                        
         
 
                            
           

                       
 



                                 
 
                            
           

                                    
 
                            
           

                     
 
                            
           

                                     
 


                                              
 

                                

         

                            

         

                            

         

                             

         

                              

         



                                     
 


                                                                    
 


















                                                                       

         

                                                 

         


                                   
 


                                   
 


                                 
 


                                
 


                              
 


                                   
 




                                                          
 


                              
 


                                           
 

                                            
         
 
                              

           

               
         
 


                                            
 


                                                 
 


                                                      
 


                                                   
 
                                                          
           

                       
 


                                                          
 


                                     
 
                              
           
                                                
         
 

                                                    
         
 



                               
 


                              
         
 



                                               
 


                                         
         
 


                                                                               
         
 



                                                      
 



                                                                             
 


                                      
 



                                                                          
 


                                   
 



                                  
 




                                                                          
 
                          
           


                                                                           
 
                          
           

                                            
 
                          
           

                                                                      
 
                          
           

                                                                             
 
                          
           

                                               
 


                                                  
 
                          

           



                                                                             
         




                                                                            
 

                                               
         
 
                          
           

                                                                       
 


                                    
 

                                      
         
 

                          
         
 










                               
           
                                     
         
 



                                  
 



                                                                          
         
 


                                         
         
 


                                    
         
 



                                         
 


                                         
 


                     
 



                     
 



                                               
 


                     
 


                     
 


                     
 


                                      
 

                                                                               
         

                                                                              
 





                                                    
         



                                                       
 


                       
 


                                                 
 


                                                          
 


                                              
 


                                                  
 


                             
 


                                        
 


                                      
 


                                                          
 





                                                       
         
 





                                           
         
 


                                                                            
         
                                                                           
 
                                        
        
                                                                          
         
                                                                               
 


                                                                       
 



                                                      
 


                                              
 


                                            
 



                                                              
 


                                            
 



                                                              
 


                                             
 


                                                              
 


                                          
 


                                
 


                        
 


                      
 


                                                         
 


                      
 


                                                       
 


                                                          
 



                                                                  
 

                                                      

         


                                                                         
 




                                                       
 


                                                                             
         
                                                                            
 


                                                          
 



                                      
 


                                       
 


                                                                 
 

                                                                              
         
                                                                               
 


                      
 


                                                                         
 


                      
 


                                        
 











                                                                           
         
                                                                             
 



                                                                            
         
                                                                               
 






                                                                               
 




                                                                                                 
 
                                                              
           

                               
 
                      
           

                         
 


                      
 
                      
           

                     
 


                      
 


                      
 


                      
 


                      
 






                                                                         
 



                      
 



                                          
 



                      
 



                                          
 


                                       
 
                      
        
                                                                               
         
                                                                               
 



                                                                        
         

                                                                        
 



                                                                          
 


                                                                         
 


                                                                         
 



                      
 



                                                 
 


                                          
 


                                                    
 


                      
 



                                             
 


                                   
 


                              
 


                                                                       
 


                                                                         
 


                          
 


                                                      
 



                             
 


                               
 



                                                                              
 


                                                    
 

                                                                          
         
                                                                          
 


                                                                           
 


                                                      
 


                                          
 


                                                                    
 

                                                                        
         
                                                                          
 


                                                   
 


                                                                         
 

                                                                     
         

                                                                        
 



                                                                            
 


                                              
 

                                                                            
         
                                                                             
 


                                                           
 


                                                         
 

                                                                 
         
                                                                           
 


                                               
 


                                                               
 


                                                                  
 

                                                                            
         
                                                                            
 



                                                                             
 


                                                                           
 


                              
 


                                                                 
 


                                                               
 




                                                    
 


                                          
 



                                                                           
 


                                                   
 



                                                                    
 


                                       
 


                                                
 


                                    
 


                                                
 


                      
 


                                     
 


                                                
 


                                                    
 


                                             
 


                                                 
 


                                                         
 


                                                    
 


                                           
 


                                                                
 


                                                                     
 


                                               
 



                      
 


                                          
 


                                          
 


                      
 



                       
 



                          
 



                                                         
 


                      
 



                                             
 


                      
 


                       
 


                      
 


                      
 


                      
 


                      
 


                      
 



                                                                 
 



                      
 


                                       
 


                      
 


                                                                    
 


                      
 


                           
 


                      
 


                                                                          
 


                      
 



                                                      
 


                      
 



                                                                       
 


                      
 



                                                                      
 


                      
 


                                                               
 



                        
 




                                                                         
 


                      
 


                                                                    
 


                                                               
 


                                                        
 


                                                                 
 


                                        
 


                                                 
 


                                                                             
 


                                          
 



                            
 


                                                        
 


                                                             
           































                                                                               
 

                    
        







                                                                        
         









                                                                               
 
                    
        





                                                                         
         






                                                                       
 



                                 
 



                                
 




                                    
 



                                    
 



                                       
 


                                                      
 


                         
 




                                                                          
 


                                      
 



                                          
 


                                        
 



                                                        
 


                                                        
 





                                                                          
 


                                                        
 


                                                                          
 



                                                                          
 




                                                                          
 


                                                                          
 



                                                         
 


                                                          
 



                                                                          
 


                                                                          
         
                                                                          
 


                                                         
 


                                              
 



                                                  
 



                                                
 


                                                
 





                                                           
         
 



                                                                          
 



                                                                          
 

                                                          
         
 



                                                                          
 


                                       
 


                                          
         
 



                                                                          
 


                                                                          
 


                                                  
 


                                                           
 



                                                           
 




                                                        
 



                                  
 


                    
 


                    
 


                                                          
 



                                                                 
 







                                                  
 


                    
 










                                                                   
 


                                                  
 



                                               
 



                                                           
 



                                                            
 






                                                                       
 



                                                     
 



                                                                   
 







                                                                           
 


                          
 



                                                            
 





                                                                           
 








                                                
 
                     
           

                                        
 



                                      
 


                                       
 


                         
 
                     
           









                                              
 
                     
           

                                                         
 
                     
           

                                                              
 


                                       
 


                                           
 



                                             
 






                                             
 




                                                                    
 





                                                        
 





                                                            
 



                                                              
 



                                                                              
 



                                                                              
 



                                        
 



                                                              
 



                                                              
 



                               
 



                                                            
 



                                
 











                                                     
 




                                               
 



                                                                     
 


                                                                         
 




                                                 
 









                                                     
 



                                                                
 



                                                 
 



                                                       
 



                                                         
 



                                                            
 


                                                                   
         
 



                                                    
 



                                                            
 



                                         
 




                                                                         
 



                                                                
 



                                 
 



                                                                          
 





                                                                         
 



                                               
 


                                                  
 
                                                                         
           



                                                     
        



                                                           
         
 





                                                                            
         
 

                     
        


                                  
         


                                     
 


                                                  
 


                          
 
                     
           






                                                      
         

                                          
 


                                                     
 
                     
           




                                                                     
         
 










                                                               
 

                        
         
 



                                               
 

                             
         
 



                                         
 


                            
 


                         
 


                            
 


                                                             
 



                                                                
 



                                 
 



                                 
 



                                 
 


                                                                      
 




                                                                             
 




                                                               
         
 


                               
 





                                
 


                                                    
 

                             
         
 




                                                                
         
 













                                                       
         
 




                            
         

                      
 


                                          
 


                              
 

                                
         
 


                                                       
 


                                               
 


                                                  
 

                                      
         
 





                                                         
         
 


                                      
 


                                                      
 



                                                      
 
                            
           
                                               
         
 
                            
           
                                           

         


                                               
 
                            
           

                  
 
                            
           

                  
 
                            
           

                           
 
                            
           
                     
         
 



                                             
 


                            
 

                            

         

                            

         





                                                           
 
                            
           

                             
 
                            
           

                               
 



                                 
 



                            
 
                            
           
                 
         
 
                            
           

                        
 
                            
           
                       
         
 


                            
         
 
                            
           

                                           
 


                                                  

         

                            

         

                            
        
    
                  
         
    



                                                                            

         
                                                      
           

                                       
 
                                                      
           
























                                                               

         

                            
         
 

                            
         
 













                            
         
 
                            
           

                                          
 




                                                      
           
                                    
         
 
                            
           





                                             
 
                            
           
                                                           
         
 
                            

        
                  
         
 










































































                                                                              
        

                                                                               

         


                                                     
 

                            

        





                                                  
         
 
                            


           

                                                                


         

                                                                       

    





                                                                     
 
                            
           




                                 
 
                            
           
                                      
         
 





                                                         
         
 



                                                   
         
 



                                                    

         




                                                               
         
 
                            
           



                                    
 


                                                  
 

                                                      

         

                                                              
         
 
                            
           



                                                      
 
                            
           


                                                         

         




                                                           
           

                                                           
 
                            
           
                                                         

         
                            
           
                                                        
         
 
                                                      
           

                                                    
 
                            
        
    
                                      
         
 
                            
        

                                      
         
 
                            

        
                                        
         
 

                                                      
         
 

                                                               
         
 







                                                                      
 


                                                      
 



                                                               
 


                                                                 
 

                                                             
         
 


                                                                
 




                                                      
 


                                                                     
 
                            
           
                

         
                            
        



                                                                       

         
                            
           
                                                    

         
                            
           
                                      

         


                                                    
 


                           
 









                           

         

















                                                     
        



                                                   

         
                            
           



                                      
        


                                                                       
    
         
 





                                                 
 

                                                
         
 

                               
         
 


                            
 


                            
 


                            
 

                                                      
         
 


                                                      
 

                                                      
         
 

                                                          
         
 

                            
         
 


                            
 
                            
           

                                                           
 
                            
           
                                                            
         
 
                            
           

                                            
 
                                                      
           

                                             
 




                                                  
 
                            
           



                                                                             
         
 





                                                                              
 






                                                               
         
 









                                                               
         
 






                                                                
         



                                                                       
 
                            
           

                                                            
 


                                     
 


                                    
 


                           
 


                           
 


                           
 


                            
 


                            
 



                              
 



                            
 



                                    
 




                                            
 



                            
 











































                                   
         
 


























































































                                                      
 



                                                   
 


                            
 


                              
 


                            
 


                            
 



                            
 


                            
 


                            
 


                                                      
 


                            
 


                            
 



                            
 



                                 
 

                            
         
 



                            
 


                            
 



                            
 


                            
 


                            
 

                            

         


                            
 


                                 
 


                            
 


                            
 


                            
 


                            
 




                             
 




                                  
 



                            
 




                                     
 




                                
 


                            
 



                                 
 



                             
 



                            
 





                                  
 



                                  
 


                                               

         


                                                       
         
 

                                   

         


                                                   
         
                                                                         
 
                     
           
                                                            

         


                                                     
         

                                                                         
 
                     
           
                                                     
         
 



                                       
 


                                                 

         

                                                               

         



                            
 
                     
           
                                                 

         



                                   
 



                                                         
 



                                                       
 
                     
           
                                  

         
                     
           

                                                                        
 
                     
           



                                                                
         
 
                     
           
                                                            
         
 
                     
           
                                                              
         
 
                     
           
                                                                           
         
 

                     
        

                                                                         

         

                     

        
                                                        
         


                                                             
 

                     
        
                                                                              

         




                                                                           
         
 




                                                                              

         
                     
        

            
         

            
 



                                                        
 



                                                     

         



                                       
 


                               

         

                                             

         



                                     
 
                     
           
                                         
         
 

                     
        
                                                                          


         

                                                                     
         
 
                     
           


                                                  
         
 

                                                                 
         
 

                     
        

                                                  

         

                                                                 
         
 

                     
        
                                                                              


         

                                                                  

         


                                                                       

         


                                                                     
         
 


                                                                    
         
 










                                                       
         
 

                                     
         
 


                                              
         
 


                                                                  
         
 


                                                          
         
 


                                                            
         
 

                                
           

                              
 
                      
           
                                          
         
 

                                
           

                               
 
                      
           
                        

         
                      

           

                                                                            

         





                                                      
           



                                                        
        

                                                             

         











                                                                      
        

                                                                           
         



                                                                        
 
                      
        

                                                              

         

                      
        

                                                                           
         


                                                                        
 
                      
           

                                                                           
         
 


                                                                               
         
 


                                                                       
         
 





                                                                
 






                                                                              
 



                                                           
 


                             
 


                                                       
 


                                         
 


                                                      
 


                                                
 



                                     
 



                                                                     
 


                                                  
 



                                            
 


                                                  
 



                                                  
 



                                                             
 



                                
 


                        
 


                                    
 


                                          
 


                                                     
 


                               
 



                                               
 


                      
 



                                                                    
 


                                  
 



                                                     
 


                                                    
 


                                          
 


                                               
 


                      
 



                               
 




                                                                             

         


                      
 


                                        

         


                                                   
 


                       
 


                                                         
 

                                                             

         

                                                               

         


                                                                               
 


                                                                               
 




                                                                              
 


                                                               
 

                                                                            
         
 

                                                                   
         
 

                                                                        
         
 






                                                                            
         
 

                                                            
         
 

                                              

         

                                                   
         
 

                          
         
 

                                                                            

         




                                                                        
 


                                                                              
         
 


                                                            
 


                                                         
 


                                                                     
 

                                                                 
         
 


                                                                   
 

                                                      

         

                                                                      
         
 





                      
           
                                                        
         
 
                      
           
                                                                             
         
 
                      
           
                                                                         

         

                      
         
 
                      
           
                          

         

                                                          

         

                                                              

         

                                                         
         
 

                                                            

         
                      
                  

                                   
 



                                         
 



                      
 

                                      
                  

                                                         
 
                      
           
                                        
         
 
                      
           
                                               
         
 

                                                              
        
        

         

          
 
                      

           

                                                                         

         


                                                  
         
 
                      
           
                    

         

                                        
         
 

                      
           
                                     
         
 
                      
           
                                           
         
 

                                                               
         
 
                      
        



                                                                          

         

                                                      
         
 


                      
 

                        

         
                      
           
                                                       
         
 

                        

         



                                                      
         
 

                                                           
         
 

                                           
         
 

                                                 
         
 



                                  
         
 

                                    
         
 

                                    
         
 




                                              
         

                                                            
 




                                                                             
         
 






                                                      
         
 



                                                          
 



                                                       
 
                            
        

                                                                      
 

                                                                       

         

                                  

         
                            
        
                                                                            

         

                                                               

         

                                                                      
         
 


                                                                           
         
 

                                                                       

         

                                                                             

         

                                                         
         
 

                                                                      
         
 

                                                                   
         
 

                                                                
         
 

                                                                   
         
 

                                                      
         
 



                                  
 
                            
        

                                                     
 

























                                                        
 
                     
           

                                          
 




                                                                      
 

                     
           
                                                                        
         






                                                                         
 

                        
           

                                                     
 









                                              
           

                                                                    
 


                                                      
 




                                                                            
 




                                                                    
 



                                        
 



                        
 





















                                                                                
 












                                                                               
         
                                                                               
 

                        
           
















                                                                            
         

                                                                       
 






                                                                            
         


                                                                           
 
                        
           

                            
 





                                                    
         
 




                                                       
         

                                                         
 



                                                
 


                                                                              
 



                                         
 

                        
        




                                                              
         





                                                            
 








                                                                               
         





                                                                  
 




                                                                
 



                                                                         
         

                                                                           
 



                                          
 





                                              
 





                                   
 



                                                                   
 



                                                               
 


                                   
 
                        
        

                                                                             
         

                                                                         
 



                                                                           
         

                                                                        
 






                                                                             
         


                                                                          
 




                                                               
 



                                                                        
         

                                                                           
 



                                                                 
 



                                                     
        

                                           
         

                                                      
 



                                                           
 



                                                                             
         

                                                                               
 


                                                                          
         

                                                                           
 



                        
 



                                                      
 



                                              
 
                         
        



                                                                           

         



                                                          
 





                                                         
 



                                                                          
         

                                                                           
 



                                                                 
 



































                                                                            
         

























                                                                        
 



                                                                            
         
 


                                                             

         




                                                 
 
                         
           


                                                                               
         
 
                         
           


                                                                        

         
                         
           
                                                                            
         
 

                                                   
         
 



                                                                  
 



                                                                
 




                                                                       
 

                                                                
         

                                                                               
 



                                                                        
         

                                                                    
 


                                                          
         
 

                                          
         

                                                                      
 

                                            
         
 




                                                                      
 
                  
                  

                                                       
 

                             
         
 
                   
        

                                         
 

                             

         
                    
           
                                                
         
 
                    
           
                                                    
         
 
                                      
           

                               
 
                    
           
                                              
         
 
                    
           
                                                  
         
 


                                                          

         


                                                                      

         
                                                        
           

                               
 
                    
           
                                               
         
 




                                       
 



                               
 

                                      
        


                                                                              
         
 


                                          
         
 


                                                                   

         





                                                                       
         
 


                                                              
         
 



                                                                          
         
 


                                         
         
 



                                            
 



                                                                        
 



                                  
 




                                                  
 




                                                 
 



                                   
 
                           
                          
         

                                                                      
                           
                             
         
 
                           
                             
         

                                                                 
                           
                         
         
 
                           
                           
         
 
                           

                 
         

                       
                           
                            
         
 
                           

                             
                                             
 
                           
                               
                                                                
 
                           

                             
         
 
                           
                           
         
 
                           
                           
         
 
                           
                              
         
 
                           

                     
                                    
 
                           
                                 
         
 
                           
                             
         
 
                           

                                
                                                          
 
                           

                                       
                                                   
 
       
                         
                           
                 
         
 
                           

                                                  
                                                            
 
                           

                                   
         

                                                              
                           
                
         

                           
                           

                           
         
 
                           
                   
         
 
                           
            
                 
 
                           
             
                 
 
                            

                    
         
 
                            

                         
         
 
                            

           



                                                                               
         
 
                                                        


                                           
                                           
                             
                                 
         
 
                                           
                             
                                
         

                                                           
                             

                                                
         




                                                      
                             

                                     
         
 
                                                

                                        
         
 
                                                

                                         
         
 
                                                

                                                              
         
 
                         

                                             
         
 

                                                                       
                                                
                       
         
 

                                                                           
                      
                  
                   
 
                                                
                           
         
 
                         
                                         
         
 
                                
                         

                                                 
         
 
                         




                       
                         
                                  
         
 
                                                




            
                         
                            
         
 
                         

                              
         
 
                         
                                             
         
 
                         


                                                             
                         
                                     
         
 
                                                                       
        
                     
                             
 
                         



                                                                   
                         

                                
         
 
                         
                 
         
 
                         
                            
         
 
                         
                                                
         
 
                         
                        

         
                         






                                                                      
 
                         

                                             
         
 
                         

                                    
         
 
                         

                                       
         
 
                         

                                  
         
 
                         

                                                 
         
 
                         

                                                      
         
 
                         

                                                  
         
 
                         

                                       
         
 
                         

                                                       
         
 
                         

                                
         
 
                         
                          
         
 
                              
        
                                  
                                         
 
                              
                                                   
         
 
                              
                  
                                 
                                         
 
                               

                      
         
 
                               

                                             
         
 
                               

                               
         
 
                           

                               
         
 
                         


                                                                      
                         
                         
         
 
                         


           
                

         
                                                                       
                               
         
 
                         
                         
         
 
                         
                       




                              
                          
                                        
         
 
                          
                                       
                                             
 
                          

                                          
         
 
                          

                                   
         
 





                                                                     
                          


                    
                          

                                          
         
 
                          




                   
                          

                                                    
         
 
                          

                                               
         
 
                          




                   





















                                                                          
                        
         
 
                          

                                            
         
 
                          

                                          
         
 
                          

                                  
         
 
                          
                         
         
 
                          




                                     
                          
                                              
         
 
                           

                          
         
 
                           

                                
         
 
                           

                        
         
 
                           

                                 
         
 
                           

                         
         
 


                            
                              
 



                              

                  
                           

                                  
                                                      
 
                           
                       
         
 
                           

                          
                                                       
 
                           
                                       
         
 
                           
                                            
         
 
                           

                                                
         
 
                           

                              
         
 
                           




            

                
 
                           
                                   
         
 
                           
                     
         
 
                           
                                             
                                                             
 
                           
                                  
         
 
                           
                           
         
 
                           

                                          
         
 
                           

                         
                                
 
                           

                   
                   
 
                           

                 
                   
 
                                           
                           

                                 
         
 
                                           
                           

                               
         
 
                                           
                           

                                     
         
 
                                           
                           

                                   
         


                        
         


                        
         


                             
                               
 
                          
                            
         
 
                                                  
                      
         
 
                          
                              
         
 


                               
                                 
                                   
 
                          
                      
         
 
                           
                
         
 
                           


                                                                  
                           



                                                                       
         
 
                           
                                            
         
 
                           
                                                                    
         
 
                                                    
                                                                    
         
 
                           
                                             
         
 
                           


                                                           
                           
                                                   
         
 
                           

                           
         
 
                           
                              
         
 
                                                    
                                                       
         
 
                           
                             
         
 
                           

                                                            
         
 
                           
                                                                       
         
 
                           
                                                  
         
 
                           

                                  
         
 
                           
                            
         
 
                           
                                   
         
 
                           
                            
         
 
                           
                             
         
 
                           
                              
         
 
                           
                                                
         
 
                           

                                 
         
 
                           
                             
         
 
                           

                                         
         
 
                           
                                           
         
 
                           
                                                   
         
 
                           
                           
         
 
                             
                                                          
         
 
                             
                                
         
 
                             

                                               
         
 
                             
                                                          
         
 
                             
                                       
         
 
       
                             

                                               
                                                
 
                             
                                                      
         
 
                             
                                      
         
 
                             
           
                          
         
 


                             
         

              
                             




                                    
                             




                                   
                             
                                              
         
 
                             

                                
         
 
                             

                                          
         
 
                             

                             
         
 






                                                           
 
                             
           

                                                
 
                             


                                              
 
                             
           


                                         
                             

                                       
 
                             


                                        
                             

                      
         
 
                             
                                       
         
 
                             


                                                             
                             
                                                
         
 
                             
           
                                        
         
 
                             
                                                
         
 
                             
                                               
         
 
                             

                                          
                                                 
 
                               
                                      
         
 
                               
                                          
         
 
                               
                                          
         
 
                               
                            

                                        
                               



                                 
                               

                                 
 
                               




                   
                      
 
                               


                              
                               
                             
         
 
                               
                                  
         
 
                               
                     
         
 
                                                      
                     
                               
 
                               
        
                             
                                      
 
                               


                                    



                                         
 
                          
                                                     
         
 
                          
                                 
         
 
                                                          
                           
                   
                                                  
 
                      
                           

                
                                    
 
                           

                     
         
 
                         
           
                                        
         
 





                                     

                                              
         
 
                         

                               
         
 
                         



                                                                
                         

                         
                                                        
 

                        
                         
                  
                          
                             
 
                         

                             
         
 
                         


                                                     
                         


                                                        
                         




                                             
           
                          
                             
 
                         

                                        
                                                        
 

                                                           
                         

                                    

                                     
                         


                                           
 
                         
           
                            
                                     
 
                         

                                        
                                                                     
 
                         

                                        
                                                       
 
                       
                                     
         
 
                       
                                      
         
 










                                                              
                                           
                                             
 
                         

                                              
                                                

                       
                         
                     
         
 
                        



                                    
                        

                                       
                                                    
 
                        



                                                      
                        

                                                     
                                                       
 
                        



                                   
                          

                         
                                              
 
                          

                                            
                                                   
 
                          



                                                  
                          


                                                                               

                                                                
 
                        
                                                    
                                                                   



                                                    
                                 





                                                    
                         

                                                     
                                                                       
 
                         

                                                
                                                                       
 
                         
                                                    
                                                        
 
                         
                                         
                                                                

     
                         
                                     
         
 





                             

                                              
                                                                   
 
                         

                                                  
                                                                           
 
                         
                                                   


                                                                             
 
                         



                                                         














                                                   
                          






                                                       


                                                  
                                                

                   
                          

                                    
                                                     

                                                     
                          

                            
                                     
 
                                                     
                          





                   
                      
 
                          

                                 
                                                   
 
                          
                        
                                       
 
                          
                      
                           

                                                                 
                           

                                   
                                                 
 
                           


                                   
                           


                       
                           


                            
                           


                                 
                           


                               
                           


                                     
                           


                                 
                           


                                        
                           


                                   
                           


                         
                           


                                              
                                                    


                                              
                           


                                              
                           


                                                

                                                                             


                                      
                           


                                            
                           


                                                
                           


                                            
                           


                                       
                           


                                        
                           


                               
                           


                                      
                           


                                
                           


                                  
                           


                                    
                           


                       
                           


                                  
                           
                                                                
                                                                 
 
                           
                                                                
                                                                 
 
                           


                                 
                           


                              
                           
                                       
                                            
 
                           
                                       
                                            
 
                           
                                  
                                    
 
                           


                              
                           


                                
                           


                                                          
                           


                                  
                           


                                  
                           
        
                                 
                                  
 
                            
                                       
         
 
                                                      

                           
                               
 
                            



                                   
                            
                                  
                                                    
 
                            

                                                 
         
 
                            

                                   
                                                            
 
                           
                                                       
                                                                
 
                        
                                           
         
 
                         
                                                      
         
 
                         

                                           
         
 
                         

                                               
         
 
                         
                                 
         
 
                         

                                    
         
 
                         

                                         
         
 
                         

                                                              





                                                  
 
                         

                                          
         
 
                    



                                              
                                      

                                  
                                            
 
                    

                                                     
                                                                 


                                                 

                                     
                    


                                                               

                                                                             
 
                    


                                                             

                                                                            
 
                    


                                                             

                                                                            
 

                                                      
                    

                                     
                                                      
 
         
                    

                                   
                                                    
 
                    


                           
                    





                                       
                                      

                                              
                                                              
 
                    



                                         





                                                             

                                       
                                                           
 
                    

                                   
                                               
 
                     

                                        
                                                     
 
                     

                                               
                                                                          
 
                     

                                                      
         

                   
                      
                                                   
                                                   
 
                      



                                                   

                                                             
 
                      





                                                                



                                                                 
 
                      




                                                                          




                                                                   
 
                      
                                                  
                                                      
 
                     
                      

                                        
                                                                
 
                      


                                             
                      
                                    
         
 
            
                      

                             
                                                          
 
                      

                                                            
         
 
                      

                                     
                                       
 
                               
                      

                                          
                                                      
 
                      

                               
                               
 
                      


                                                                         
       
                      






                                                                     

                             
                     
              
                        
            

                                                                        
                                                              


                                
                      






                                                                          
                                                                             







                                                    
                                             
 
                    

                                                             
                                                       
 
                    

                                                     
                                                 
 
                    

                                            
                                                        
 
                                      




                                                
                    



                                                                
                    



                                             
                    
                    
                                 
 
                    

                                           
                                                 
 
                    
                                          
                                                        
 
                    
                                   
                                               
 
                    
                                                    
         
 
                    

                                                
                                                     
 
                    
                                              
         
 
                    
                                               
         
 
                    

                                
                                          
 
                    
           
                                                   
                                                                     
 
                    

                                   
                                                           
 
                                       

                              
                                                      
 
                    

                                                                           
                                                                            
 
                    

                                                            
 
                    


                                                                          

                                                              
 
                    
                                                   
                                                     

                    
                    
                           
                                        
 
                                      

                                                
                                                  
 
                               
                    
                                
                                  
 
                    
                                             
         


                                                                    
                                      

                         
                                      


                        
                    
                                   
                                          
 
                    

                                            
                                                                    
 
                    

                                            
                                             
 
                    



                                                           
                                   
 
                    

                                               
                                              
 
                    





                                             
                    


                                                    

                                                     
 
                    




                                                           


                                                           
 
                    
                        
                              
 
                    

                                        
                                                     
 
                    
           
                                 
                                      
 
                    

                                                 
                                                                         
 
                    

                                    
                                           
 
                    
                                        
                                                 
 
                    


                                                                     

                                                     

              
                    


                                                        

                                                         
 
                    




                                                             

                                                            
 
             
                    


                                                              

                                              
 
                    

                                       
                                                   
 
                    

                                             
                                                            
 

                                     
                    
                     
                                 
 
                    
           
                                          
                                                           
 
                     
           
                                                                   

         
                           
                     


                                                          

                                                
 
                     

                                        
                                                                         
 
                                        
                     


             
      
                     
             
              
 
                                        
                                      
                                                 
 
                     

                                                                         

                                                      



                             
                     

                                     
                                                      
 
                
                     

                                 
                                  
 
                     



                                                 
                     

















                                                                     



                                             
                     
                                    
                                        
 
                     

                                            
                                                    
 
                     

                            
                           
 


                           
 
                     

                                   
                                            
 
                     

                                        
                                                    
 
                             
           

                                                                          
         
 
                             
                       
                              
 
                                 

                                                            
                                                               
 


                                                             
                                 
           

                                                           

                                                                   
 
                                 

                                                    
 

                                                  
                                 

                                   
                                            
 
                                 
           
                   
                      
 
                       
                                                   
         
 
                       
                                                          
                                                               
 
                       


                                                          
                                            

                                         
                                                              
 
                       
                                     
         
 
                       
                                                 
         
 
                       
                                              
                                               
 
                       
                                                  
                                                               
 
                       



                                                 
                       
                                                  
                                                               
 
                       

                                        
                                            
 
                       
                                      
         
 
                       


                                               
                       
                  
         
 
                       
                        
         
 




                                               
                                          
         
 
                       

                                      
         
 
                       
                   
         
 
                       

                                           
         
 
                      
                            
                                                








                                            
                    









                                                   
      


                                    
                                                          

         


                                                                           
         

                                                                        
 
       
                     

                                                              
                                                                               
 
                     

                                
                                         
 
                       
                    
                                                 
                                                                     
 
                     

                                 
                                       
 
                     

                                          
                                                               
 
                     
                                         
         
 
                     

                                        
                                                          
 
                     

                               
                                       
 
                     

                                          
                                                            
 



                                           

                                                
                     

                                  
                                                         
 
                     



                                   
                     

                                               
         
 
                     



                                                     
                     



                       
                     
        
                                      
                                           
 
                     
                  
                                                 
                                                             
 
     
                     
                  
                                               
                                                                      
 
                     

                                                
         
 
                     

                     
         
 
                     
                                                          
                                                                           
 
                     




                                                       
                        


                                                                     
                     

                             
                                  
 
                     

                                   
                                           
 
                     

                                                     
                                                   
 
                     

                                                     
                                                      
 
                     

                                                             
                                                                    
 
                     

                                                 
         
 
                     

                                                
                                                    
 
                     

                                              
                                                
 



                                         
                            
                                                             
                                                                
 
                            
                                     
                                       
 
                         





                                                                         
                         









                                                                             
         



                               
         



                                   
         



                                    
         



                                        
         







                                                                               

                                                                       

                           
                                     



                                          
         
 
                         

                                               
         
 
                                                                       

                                        
         
 
                                                                       

                                      
         
 
                         
           
                                                           
         
 


                                                           
         
 
                         
                                
         
 
                                                
                           
         
 
                                                

                                        
         
 
                         
           

                                                                              
         
 
                         

                                                   
         
 
                         




                                                                          
                         

                                          
         
 
         
                       

                                                
                                                      
 
                       
           
                        
         

                       
           
                                  
         



                                            
                                              
 
                        
           
                                   
         
 
                        
                             
         
 
                       

                                  
                                  
 
                       

                               
                                
 
                       

                           
                                             
 
                       
           

                                                                             
         
 
                       





                           
                       




                        
                       






                  
                       




                  
                       


                                                                 
                       


                                                 
                       
                                              
         
 


                                                         
           

                                             
 
                       
           

                                           
 
                       
           

                                                
 



                                              
 
                       
                                              
         
 
                       

                               
         
 
                       

                             
         
 
                       

                             
         
 
                       

                             
         
 
                       

                                                        
         
 
                       
                                                               
         
 


                                                                 
                                         
 

                                                                 
             
         
 

                                                                 
        
             
               
 
                                                                 
            
             
 
                                                                 
            
             
 
                                                                 
           
            
 
                                            
           
            
 
                       
                                                                  
         
 
                       

                                       
                                      
 


                                                                 
        
             
                 
 
                       
                
         
 
                       
                
         
 
                       
               
         
 
                       
                                                       
         
 


                                            
                               
 
                       
            
         
 
                       
            
         
 
                       
                                                
         
 


                                                   
                                              
 
                                                                 
           
         
 
                       
             
              
 
                       
              
         
 
                                            
              
               
 






                                                                 
 
                       
            
         
 
                       
              
         
 
                       
                                              
         
 
                       
                                          
         
 
                       

                                   
         
 
                       

                                       
         
 
                       

                                         
         
 
                       

                                     
         
 
                       

                                  
         
 
                       
                                          
         
 
                       

                          
         
 
                       

                                   
         
 
                       
                                                          
         
 
                                            
             
         
 
                       
                                                              
         
 


                                      
                                       
 
                       
               
         
 
                       
                    
         
 
                       
                                          
         
 



                                             
 
                       
             
         
 




                                                  
                                          
         
 
                       

                                     
         
 
                       

                                          
         
 
                       

                                                
         
 
                       
                                          
         
 
                       

                               
         
 
                       

                           
         
 
                       

                               
         
 
                       
                                                         
         
 

                                                                 
             
         
 
                       
                                                               
         
 


                                      
                                     
 
                       
            
         
 
                       
            
         
 
                       
              
         
 
                       
                                             
         
 
                       
             
         
 
                       
             
         
 
                       
                                        
         
 



                                             
 
                       
                  
         
 
                       
                
         
 
                       





                                  
                         
                       

                                          
         
 
                         
                       

                                    
         
 
                       
           

                                                
 
                       
           
                           
         
 



                           
 
                                            
                  
                              
                           
 
                       





                          
                       

                                                    
         
 
                       
           

                                                              
 
                       
                  
                            
                           
 
                       
                  
                           
                   
 
                       





                            
                       

                                             
                                              
 
                       

                                    
         
 
                       
           

                      
 


                          
                   
 


                          
                   
 


                                       
                                    
 
                       
              
         
 
                       
        
             
             
 
                       
              
         
 
                       
              
         
 
                       
           
            
 

                                                                        
         
 
                                          
                      
        


                                                                          
                                                                            
 
                      
                                                                

         
                      
                                                                             
         
 
                      
                                                              
         
 
                      
                                                                  
         
 
                      
                                                               
         
 

                      
                                                         
                                                                  
 

                      
                                                         
                                                                  
 
                      
        
                                                         
                                                                  
 
                      



                                                                              
                      


                                                                   



                       
                             




                                       
                                                           






                                                            





                              

                       
                        
 
                              

                           
         
 
                                                          

                                    
         
 
                              

                                         
                                                   
 
                              




                                                           
             
         
 
                        


                                                                            
                                                                             
 
                        



                                           
                         



                                      
                                                


                    
                         


                    
                         



                                                     
                        

                                     
                                             
 
                        






                                                                           
                        
                    
         
 
                         


                              
 
                         

                                  
                                    
 
                         

                       
                                   
 
                         
              
                 
 
                         
               
                 
 
                         
                      
                      
 

                         
                 
                  
 
                         
               
                 
 
                         
                      
                          
 
                         

                         
                            
 
                         

                          
         
 

                       
                                  
                                                        
 
                       
                                       
                                                
 
                       
                           
                                      
 

                                           

                                         
         
 
                       
                       
         
 
                       
                               
         
 
                         

                                             
                                                
 
                          


                          
                          
                                                     
                                                        


                                    
         


                                  
         





                                                                              
                        
           
                                                                     
         
                                                                              
 
                        










                           
                        









                                         
                        
                            
                                            
 
                        
                
                 
 
                        



                            
                        
                                               
                                                     
 







                             

                             
                         

                           
                                 
 
                         








                
                         
                            
                                           
 
                                                
                                     
                                     
 
                         

                      
                        
 
                         

                            
                                       
 
                         


                     
                         
                     
                         
 
                         
                                
                                              
 
                         






                               
                         


                                    
                         
                    
                                             
 
                         




              
             
 


                            
                    
 


                                 

                          
                         


                          
                         
                                             
                                                            


                                                       
         







                                                                       
         



                                 
                                          

                        




                                                                  
         



                                                              
         

                         
             
                                                            
         

                         
                  
                                  
                                          


                                                 
         
 
                       
                                        
                                                               
 
                       
                               
                                  
 
                      

                                             
                                                          
 
                      
                                
                                                   
 
                      

                                                  
                                                           
 
                      
                                    
                                                               
 
                      
                              
                                    
 
                      
                                            
                                                           
 

























































                                                                              

                                                                           
 


                                                                           

                                                                           
 


                                                          
 

                                                  
 

                                                               
 

                      
 

                                                        
 

                                         
 

                                            
 


                                           
 








                                                                               
 
                                                                         
            



                                                                               







                                                                           
                          
                                                 

                                                                           

                                                                       
 



                                    








                                                                     
            
                                                                              
 



                                                           
 




                                                                       
 












                                                                               

                                          
                                                       


                                                                 
                                                                           

                                                            
                                                                         

                                           
                                          

                        
                                  
# German translation for util-linux.
# Copyright (C) 1999, 2000, 2001 Elrond <Elrond@Wunder-Nett.org>; Copyright (C) 2001 Karl Eichwalder.
# Karl Eichwalder <ke@suse.de>, 2001.
# Elrond <Elrond@Wunder-Nett.org>, 1999-2001.
#
# Note:
# =====
# Changes done by Karl Eichwalder are put into the Public Domain.
#
# As requested here is the unmodified header:
#
# -=-=-=-=-=-=-=-=-=-=-=-=-=- cut here -=-=-=-=-=-=-=-=-=-=-=-=-=-
# German translation for util-linux.
# Copyright (C) 1999, 2000, 2001 Elrond <Elrond@Wunder-Nett.org>.
# Elrond <Elrond@Wunder-Nett.org>, 1999-2001.
#
# $Revision: 1.42 $
#
# Permission is granted to freely copy and distribute
# this file and modified versions, provided, that this
# header is not removed and modified versions are marked
# as such.
#
# If you have additions/changes/other requests, please
# send them to me (Elrond <Elrond@Wunder-Nett.org>)!
#
# People who helped or contributed (in historical order):
#   Martin Schulze <joey@infodrom.north.de>
#   Daniel Egger <Daniel.Egger@suse.de>
#   deliA <deliA@Wunder-Nett.org>
#
# Submitted to the TP 2001-07-18 14:32:47 CEST -ke-
#
# -=-=-=-=-=-=-=-=-=-=-=-=-=- cut here -=-=-=-=-=-=-=-=-=-=-=-=-=-
#
# Hinweise zur Übersetzung:
# =========================
# command - Befehl
#
msgid ""
msgstr ""
"Project-Id-Version: util-linux 2.11l\n"
"POT-Creation-Date: 2001-11-05 01:32+0100\n"
"PO-Revision-Date: 2001-11-01 17:45+0100\n"
"Last-Translator: Karl Eichwalder <ke@suse.de>\n"
"Language-Team: German <de@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"

#: disk-utils/blockdev.c:50
msgid "set read-only"
msgstr ""

#: disk-utils/blockdev.c:51
msgid "set read-write"
msgstr ""

#: disk-utils/blockdev.c:54
msgid "get read-only"
msgstr ""

#: disk-utils/blockdev.c:57
msgid "get sectorsize"
msgstr ""

#: disk-utils/blockdev.c:60
msgid "get blocksize"
msgstr ""

#: disk-utils/blockdev.c:63
msgid "set blocksize"
msgstr ""

#: disk-utils/blockdev.c:66
msgid "get size"
msgstr ""

#: disk-utils/blockdev.c:69
msgid "set readahead"
msgstr ""

#: disk-utils/blockdev.c:72
msgid "get readahead"
msgstr ""

#: disk-utils/blockdev.c:75
msgid "flush buffers"
msgstr ""

#: disk-utils/blockdev.c:79
msgid "reread partition table"
msgstr ""

#: disk-utils/blockdev.c:88
#, c-format
msgid "Usage: %s [-V] [-v|-q] commands devices\n"
msgstr "Aufruf: %s [-V] [-v|-q] Befehle Geräte\n"

#: disk-utils/blockdev.c:89
msgid "Available commands:\n"
msgstr "Verfügbare Befehle:\n"

#: disk-utils/blockdev.c:191
#, c-format
msgid "%s: Unknown command: %s\n"
msgstr "%s: Unbekannter Befehl: %s\n"

#: disk-utils/blockdev.c:202 disk-utils/blockdev.c:211
#, c-format
msgid "%s requires an argument\n"
msgstr "%s erwartet ein Argument\n"

#: disk-utils/elvtune.c:46 disk-utils/setfdprm.c:100
msgid "usage:\n"
msgstr "Aufruf:\n"

#: disk-utils/fdformat.c:35
msgid "Formatting ... "
msgstr "Formatieren ... "

#: disk-utils/fdformat.c:53 disk-utils/fdformat.c:88
msgid "done\n"
msgstr "Beendet\n"

#: disk-utils/fdformat.c:64
msgid "Verifying ... "
msgstr "Überprüfen ... "

# This is from a perror()
#: disk-utils/fdformat.c:75
msgid "Read: "
msgstr "Lesen: "

#: disk-utils/fdformat.c:77
#, c-format
msgid "Problem reading cylinder %d, expected %d, read %d\n"
msgstr ""
"Problem beim Lesen von Zylinder %d, es wurde %d erwartet, aber %d gelesen\n"

# Oh, well, that doesn't sound pretty good.
#: disk-utils/fdformat.c:83
#, c-format
msgid ""
"bad data in cyl %d\n"
"Continuing ... "
msgstr ""
"Schlechte Daten bei Zylinder %d\n"
"Operation wird fortgesetzt ... "

#: disk-utils/fdformat.c:98
#, c-format
msgid "usage: %s [ -n ] device\n"
msgstr "Aufruf: %s [ -n ] Gerät\n"

# "mkfs aus util-linux-2.10d"
# "mkfs von util-linux-2.10d"
#: disk-utils/fdformat.c:120 disk-utils/fsck.minix.c:1261
#: disk-utils/isosize.c:179 disk-utils/mkfs.bfs.c:119 disk-utils/mkfs.c:55
#: disk-utils/mkfs.minix.c:644 disk-utils/mkswap.c:452
#: disk-utils/setfdprm.c:128 misc-utils/cal.c:227 misc-utils/ddate.c:181
#: misc-utils/kill.c:188 misc-utils/rename.c:79 misc-utils/script.c:132
#, c-format
msgid "%s from %s\n"
msgstr "%s von %s\n"

#: disk-utils/fdformat.c:134
#, c-format
msgid "%s: not a floppy device\n"
msgstr "%s ist kein Diskettenlaufwerk\n"

#: disk-utils/fdformat.c:143
msgid "Could not determine current format type"
msgstr "Konnte das aktuelle Format nicht feststellen"

#: disk-utils/fdformat.c:144
#, c-format
msgid "%s-sided, %d tracks, %d sec/track. Total capacity %d kB.\n"
msgstr "%sseitig, %d Spuren, %d Sektoren/Spur, Totale Kapazität: %dkB.\n"

#: disk-utils/fdformat.c:145
msgid "Double"
msgstr "Doppel"

#: disk-utils/fdformat.c:145
msgid "Single"
msgstr "Einfach"

#: disk-utils/fsck.minix.c:197
#, c-format
msgid "Usage: %s [-larvsmf] /dev/name\n"
msgstr "Aufruf: %s [-larvsmf] /dev/name\n"

#: disk-utils/fsck.minix.c:296
#, c-format
msgid "%s is mounted.\t "
msgstr "%s ist gemountet (mount).\t"

#: disk-utils/fsck.minix.c:298
msgid "Do you really want to continue"
msgstr "Fortfahren"

#: disk-utils/fsck.minix.c:302
msgid "check aborted.\n"
msgstr "Überprüfung abgebrochen. \n"

#: disk-utils/fsck.minix.c:319 disk-utils/fsck.minix.c:339
msgid "Zone nr < FIRSTZONE in file `"
msgstr ""

#: disk-utils/fsck.minix.c:321 disk-utils/fsck.minix.c:341
msgid "Zone nr >= ZONES in file `"
msgstr ""

#: disk-utils/fsck.minix.c:325 disk-utils/fsck.minix.c:345
#: disk-utils/fsck.minix.c:759 disk-utils/fsck.minix.c:793
msgid "'."
msgstr ""

#: disk-utils/fsck.minix.c:326 disk-utils/fsck.minix.c:346
msgid "Remove block"
msgstr "Block entfernen"

#: disk-utils/fsck.minix.c:364
msgid "Read error: unable to seek to block in file '"
msgstr ""

#: disk-utils/fsck.minix.c:366 disk-utils/fsck.minix.c:372
#: disk-utils/fsck.minix.c:396 disk-utils/fsck.minix.c:643
#: disk-utils/fsck.minix.c:694
msgid "'\n"
msgstr ""

#: disk-utils/fsck.minix.c:370
msgid "Read error: bad block in file '"
msgstr ""

#: disk-utils/fsck.minix.c:386
msgid ""
"Internal error: trying to write bad block\n"
"Write request ignored\n"
msgstr ""

#: disk-utils/fsck.minix.c:392 disk-utils/mkfs.minix.c:285
msgid "seek failed in write_block"
msgstr ""

#: disk-utils/fsck.minix.c:394
msgid "Write error: bad block in file '"
msgstr ""

#: disk-utils/fsck.minix.c:513
msgid "seek failed in write_super_block"
msgstr ""

#: disk-utils/fsck.minix.c:515 disk-utils/mkfs.minix.c:272
msgid "unable to write super-block"
msgstr "Konnte den Superblock nicht schreiben"

#: disk-utils/fsck.minix.c:525
msgid "Unable to write inode map"
msgstr "Konnte die »inode map« nicht schreiben"

#: disk-utils/fsck.minix.c:527
msgid "Unable to write zone map"
msgstr "Konnte die »zone map« nicht schreiben"

#: disk-utils/fsck.minix.c:529
msgid "Unable to write inodes"
msgstr "Konnte die »inodes map« nicht schreiben"

#: disk-utils/fsck.minix.c:558
msgid "seek failed"
msgstr "»seek« gescheitert."

#: disk-utils/fsck.minix.c:560
msgid "unable to read super block"
msgstr "Konnte den Superblock nicht lesen"

#: disk-utils/fsck.minix.c:580
msgid "bad magic number in super-block"
msgstr "Ungültige »magic number« im Superblock"

#: disk-utils/fsck.minix.c:582
msgid "Only 1k blocks/zones supported"
msgstr "Es werden nur Blöcke/Zonen von 1k Größe unterstützt"

#: disk-utils/fsck.minix.c:584
msgid "bad s_imap_blocks field in super-block"
msgstr "Ungültiger Wert im Feld »s_imap_block« im Superblock"

#: disk-utils/fsck.minix.c:586
msgid "bad s_zmap_blocks field in super-block"
msgstr "Ungültiger Wert im Feld »s_zmap_block« im Superblock"

#: disk-utils/fsck.minix.c:593
msgid "Unable to allocate buffer for inode map"
msgstr "Kein Speicherplatz für »inode map« verfügbar"

#: disk-utils/fsck.minix.c:601
msgid "Unable to allocate buffer for inodes"
msgstr "Kein Speicherplatz für »inodes« verfügbar"

#: disk-utils/fsck.minix.c:604
msgid "Unable to allocate buffer for inode count"
msgstr "Kein Speicherplatz für »inode count« verfügbar"

#: disk-utils/fsck.minix.c:607
msgid "Unable to allocate buffer for zone count"
msgstr "Kein Speicherplatz für »zone count« verfügbar"

#: disk-utils/fsck.minix.c:609
msgid "Unable to read inode map"
msgstr "Kann »inode map« nicht lesen"

#: disk-utils/fsck.minix.c:611
msgid "Unable to read zone map"
msgstr "Kann »zone map« nicht lesen"

#: disk-utils/fsck.minix.c:613
msgid "Unable to read inodes"
msgstr "Kann »inodes« nicht lesen."

#: disk-utils/fsck.minix.c:615
msgid "Warning: Firstzone != Norm_firstzone\n"
msgstr "Warnung: Firstzone != Norm_firstzone\n"

#: disk-utils/fsck.minix.c:620 disk-utils/mkfs.minix.c:526
#, c-format
msgid "%ld inodes\n"
msgstr "%ld inodes\n"

#: disk-utils/fsck.minix.c:621 disk-utils/mkfs.minix.c:527
#, c-format
msgid "%ld blocks\n"
msgstr "%ld Blöcke\n"

#: disk-utils/fsck.minix.c:622 disk-utils/mkfs.minix.c:528
#, c-format
msgid "Firstdatazone=%ld (%ld)\n"
msgstr "Firstdatazone=%ld (%ld)\n"

#: disk-utils/fsck.minix.c:623 disk-utils/mkfs.minix.c:529
#, c-format
msgid "Zonesize=%d\n"
msgstr "Zonesize=%d\n"

#: disk-utils/fsck.minix.c:624
#, c-format
msgid "Maxsize=%ld\n"
msgstr "Maxsize=%ld\n"

#: disk-utils/fsck.minix.c:625
#, c-format
msgid "Filesystem state=%d\n"
msgstr "Filesystem state=%d\n"

#: disk-utils/fsck.minix.c:626
#, c-format
msgid ""
"namelen=%d\n"
"\n"
msgstr ""
"namelen=%d\n"
"\n"

#: disk-utils/fsck.minix.c:640 disk-utils/fsck.minix.c:691
#, c-format
msgid "Inode %d marked not used, but used for file '"
msgstr ""
"Inode %d ist als unbenutzt gekennzeichnet, aber die folgende\n"
"Datei benutzt sie: '"

#: disk-utils/fsck.minix.c:645 disk-utils/fsck.minix.c:696
msgid "Mark in use"
msgstr "Inode als benutzt kennzeichnen"

#: disk-utils/fsck.minix.c:667 disk-utils/fsck.minix.c:716
#, c-format
msgid " has mode %05o\n"
msgstr "hat Mode %05o\n"

#: disk-utils/fsck.minix.c:673 disk-utils/fsck.minix.c:721
msgid "Warning: inode count too big.\n"
msgstr "Warnung: »inode count« zu gross.\n"

#: disk-utils/fsck.minix.c:734
msgid "root inode isn't a directory"
msgstr "»root inode« ist kein Verzeichnis"

#: disk-utils/fsck.minix.c:757 disk-utils/fsck.minix.c:791
msgid "Block has been used before. Now in file `"
msgstr ""

#: disk-utils/fsck.minix.c:760 disk-utils/fsck.minix.c:794
#: disk-utils/fsck.minix.c:1119 disk-utils/fsck.minix.c:1128
#: disk-utils/fsck.minix.c:1175 disk-utils/fsck.minix.c:1184
msgid "Clear"
msgstr ""

#: disk-utils/fsck.minix.c:769 disk-utils/fsck.minix.c:803
#, c-format
msgid "Block %d in file `"
msgstr ""

#: disk-utils/fsck.minix.c:771 disk-utils/fsck.minix.c:805
msgid "' is marked not in use."
msgstr ""

#: disk-utils/fsck.minix.c:772 disk-utils/fsck.minix.c:806
msgid "Correct"
msgstr ""

#: disk-utils/fsck.minix.c:951 disk-utils/fsck.minix.c:1016
#, fuzzy
msgid "The directory '"
msgstr "Konnte nicht in das Verzeichnis %s wechseln!\n"

#: disk-utils/fsck.minix.c:953 disk-utils/fsck.minix.c:1018
#, c-format
msgid "' contains a bad inode number for file '%.*s'."
msgstr ""

#: disk-utils/fsck.minix.c:955 disk-utils/fsck.minix.c:1020
msgid " Remove"
msgstr ""

#: disk-utils/fsck.minix.c:969 disk-utils/fsck.minix.c:1034
msgid ": bad directory: '.' isn't first\n"
msgstr ""

#: disk-utils/fsck.minix.c:976 disk-utils/fsck.minix.c:1042
msgid ": bad directory: '..' isn't second\n"
msgstr ""

#: disk-utils/fsck.minix.c:1074
msgid "internal error"
msgstr "interner Fehler"

#: disk-utils/fsck.minix.c:1077 disk-utils/fsck.minix.c:1095
msgid ": bad directory: size < 32"
msgstr ""

#: disk-utils/fsck.minix.c:1108
msgid "seek failed in bad_zone"
msgstr ""

#: disk-utils/fsck.minix.c:1118 disk-utils/fsck.minix.c:1174
#, c-format
msgid "Inode %d mode not cleared."
msgstr ""

#: disk-utils/fsck.minix.c:1127 disk-utils/fsck.minix.c:1183
#, c-format
msgid "Inode %d not used, marked used in the bitmap."
msgstr ""

#: disk-utils/fsck.minix.c:1133 disk-utils/fsck.minix.c:1189
#, c-format
msgid "Inode %d used, marked unused in the bitmap."
msgstr ""

#: disk-utils/fsck.minix.c:1139 disk-utils/fsck.minix.c:1194
#, c-format
msgid "Inode %d (mode = %07o), i_nlinks=%d, counted=%d."
msgstr ""

#: disk-utils/fsck.minix.c:1141 disk-utils/fsck.minix.c:1196
msgid "Set i_nlinks to count"
msgstr ""

#: disk-utils/fsck.minix.c:1153 disk-utils/fsck.minix.c:1208
#, c-format
msgid "Zone %d: marked in use, no file uses it."
msgstr ""

#: disk-utils/fsck.minix.c:1154 disk-utils/fsck.minix.c:1210
msgid "Unmark"
msgstr ""

#: disk-utils/fsck.minix.c:1159 disk-utils/fsck.minix.c:1215
#, c-format
msgid "Zone %d: in use, counted=%d\n"
msgstr ""

#: disk-utils/fsck.minix.c:1162 disk-utils/fsck.minix.c:1218
#, c-format
msgid "Zone %d: not in use, counted=%d\n"
msgstr ""

#: disk-utils/fsck.minix.c:1190
msgid "Set"
msgstr ""

#: disk-utils/fsck.minix.c:1266 disk-utils/mkfs.minix.c:649
#: disk-utils/mkfs.minix.c:652
msgid "bad inode size"
msgstr ""

#: disk-utils/fsck.minix.c:1269
msgid "bad v2 inode size"
msgstr ""

#: disk-utils/fsck.minix.c:1295
msgid "need terminal for interactive repairs"
msgstr ""

#: disk-utils/fsck.minix.c:1299
#, c-format
msgid "unable to open '%s'"
msgstr "Konnte %s nicht öffnen"

#: disk-utils/fsck.minix.c:1314
#, c-format
msgid "%s is clean, no check.\n"
msgstr ""

#: disk-utils/fsck.minix.c:1318
#, c-format
msgid "Forcing filesystem check on %s.\n"
msgstr ""

#: disk-utils/fsck.minix.c:1320
#, c-format
msgid "Filesystem on %s is dirty, needs checking.\n"
msgstr ""

#: disk-utils/fsck.minix.c:1349
msgid ""
"\n"
"%6ld inodes used (%ld%%)\n"
msgstr ""

#: disk-utils/fsck.minix.c:1354
msgid "%6ld zones used (%ld%%)\n"
msgstr ""

#: disk-utils/fsck.minix.c:1356
#, c-format, ycp-format
msgid ""
"\n"
"%6d regular files\n"
"%6d directories\n"
"%6d character device files\n"
"%6d block device files\n"
"%6d links\n"
"%6d symbolic links\n"
"------\n"
"%6d files\n"
msgstr ""

#: disk-utils/fsck.minix.c:1369
msgid ""
"----------------------------\n"
"FILE SYSTEM HAS BEEN CHANGED\n"
"----------------------------\n"
msgstr ""

#: disk-utils/isosize.c:129
#, fuzzy, c-format
msgid "%s: failed to open: %s\n"
msgstr "Konnte %s nicht öffnen\n"

#: disk-utils/isosize.c:135
#, c-format
msgid "%s: seek error on %s\n"
msgstr ""

#: disk-utils/isosize.c:141
#, c-format
msgid "%s: read error on %s\n"
msgstr ""

#: disk-utils/isosize.c:150
#, c-format
msgid "sector count: %d, sector size: %d\n"
msgstr ""

#: disk-utils/isosize.c:198
#, c-format
msgid "%s: option parse error\n"
msgstr ""

#: disk-utils/isosize.c:206
#, c-format
msgid "Usage: %s [-x] [-d <num>] iso9660-image\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:88
#, c-format
msgid ""
"Usage: %s [-v] [-N nr-of-inodes] [-V volume-name]\n"
"       [-F fsname] device [block-count]\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:135
msgid "volume name too long"
msgstr ""

#: disk-utils/mkfs.bfs.c:142
msgid "fsname name too long"
msgstr ""

#: disk-utils/mkfs.bfs.c:167
#, c-format
msgid "cannot stat device %s"
msgstr ""

#: disk-utils/mkfs.bfs.c:171
#, c-format
msgid "%s is not a block special device"
msgstr "%s ist kein blockorientiertes Gerät"

#: disk-utils/mkfs.bfs.c:176
#, c-format
msgid "cannot open %s"
msgstr "es ist nicht möglich, %s zu öffnen"

#: disk-utils/mkfs.bfs.c:187
#, c-format
msgid "cannot get size of %s"
msgstr "es ist nicht möglich, die Größe von %s festzustellen"

#: disk-utils/mkfs.bfs.c:192
#, c-format
msgid "blocks argument too large, max is %lu"
msgstr ""

#: disk-utils/mkfs.bfs.c:207
msgid "too many inodes - max is 512"
msgstr ""

#: disk-utils/mkfs.bfs.c:216
#, c-format
msgid "not enough space, need at least %lu blocks"
msgstr ""

#: disk-utils/mkfs.bfs.c:228 fdisk/fdisk.c:2025
#, c-format
msgid "Device: %s\n"
msgstr "Gerät: %s\n"

#: disk-utils/mkfs.bfs.c:229
#, c-format
msgid "Volume: <%-6s>\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:230
#, c-format
msgid "FSname: <%-6s>\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:231
#, c-format
msgid "BlockSize: %d\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:233
#, c-format
msgid "Inodes: %d (in 1 block)\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:236
#, c-format
msgid "Inodes: %d (in %ld blocks)\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:238
#, c-format
msgid "Blocks: %ld\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:239
#, c-format
msgid "Inode end: %d, Data end: %d\n"
msgstr ""

#: disk-utils/mkfs.bfs.c:244
msgid "error writing superblock"
msgstr "Fehler beim Schreiben des Superblocks"

#: disk-utils/mkfs.bfs.c:264
msgid "error writing root inode"
msgstr ""

#: disk-utils/mkfs.bfs.c:269
msgid "error writing inode"
msgstr ""

#: disk-utils/mkfs.bfs.c:272
msgid "seek error"
msgstr ""

#: disk-utils/mkfs.bfs.c:278
msgid "error writing . entry"
msgstr ""

#: disk-utils/mkfs.bfs.c:282
msgid "error writing .. entry"
msgstr ""

#: disk-utils/mkfs.bfs.c:286
#, c-format
msgid "error closing %s"
msgstr "Fehler beim Schließen von %s"

#: disk-utils/mkfs.c:76
msgid "Usage: mkfs [-V] [-t fstype] [fs-options] device [size]\n"
msgstr "Aufruf: mkfs [-V] [-t FS-Typ] [FS-Optionen] Gerät [Größe]\n"

#: disk-utils/mkfs.c:90 fdisk/cfdisk.c:371 getopt-1.1.2/getopt.c:89
#: getopt-1.1.2/getopt.c:99 login-utils/wall.c:237
#, c-format
msgid "%s: Out of memory!\n"
msgstr "%s: Speicher ist aufgebraucht!\n"

#: disk-utils/mkfs.c:99
#, c-format
msgid "mkfs version %s (%s)\n"
msgstr "mkfs Version %s (%s)\n"

#: disk-utils/mkfs.minix.c:181
#, c-format
msgid "Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]\n"
msgstr "Aufruf: %s [-c | -l Datei] [-nXX] [-iXX] /dev/Name [Blöcke]\n"

#: disk-utils/mkfs.minix.c:205
#, c-format
msgid "%s is mounted; will not make a filesystem here!"
msgstr ""

#: disk-utils/mkfs.minix.c:266
msgid "seek to boot block failed in write_tables"
msgstr ""

#: disk-utils/mkfs.minix.c:268
msgid "unable to clear boot sector"
msgstr ""

#: disk-utils/mkfs.minix.c:270
msgid "seek failed in write_tables"
msgstr ""

#: disk-utils/mkfs.minix.c:274
msgid "unable to write inode map"
msgstr ""

#: disk-utils/mkfs.minix.c:276
msgid "unable to write zone map"
msgstr ""

#: disk-utils/mkfs.minix.c:278
msgid "unable to write inodes"
msgstr ""

#: disk-utils/mkfs.minix.c:287
msgid "write failed in write_block"
msgstr ""

#. Could make triple indirect block here
#: disk-utils/mkfs.minix.c:295 disk-utils/mkfs.minix.c:369
#: disk-utils/mkfs.minix.c:419
msgid "too many bad blocks"
msgstr ""

#: disk-utils/mkfs.minix.c:303
msgid "not enough good blocks"
msgstr ""

#: disk-utils/mkfs.minix.c:515
msgid "unable to allocate buffers for maps"
msgstr ""

#: disk-utils/mkfs.minix.c:524
msgid "unable to allocate buffer for inodes"
msgstr ""

#: disk-utils/mkfs.minix.c:530
#, c-format
msgid ""
"Maxsize=%ld\n"
"\n"
msgstr ""

#: disk-utils/mkfs.minix.c:544
msgid "seek failed during testing of blocks"
msgstr ""

#: disk-utils/mkfs.minix.c:552
msgid "Weird values in do_check: probably bugs\n"
msgstr ""

#: disk-utils/mkfs.minix.c:583 disk-utils/mkswap.c:362
msgid "seek failed in check_blocks"
msgstr ""

#: disk-utils/mkfs.minix.c:592
msgid "bad blocks before data-area: cannot make fs"
msgstr ""

#: disk-utils/mkfs.minix.c:598 disk-utils/mkfs.minix.c:620
#, c-format
msgid "%d bad blocks\n"
msgstr ""

#: disk-utils/mkfs.minix.c:600 disk-utils/mkfs.minix.c:622
msgid "one bad block\n"
msgstr ""

#: disk-utils/mkfs.minix.c:610
msgid "can't open file of bad blocks"
msgstr ""

#: disk-utils/mkfs.minix.c:681
#, c-format
msgid "%s: not compiled with minix v2 support\n"
msgstr ""

#: disk-utils/mkfs.minix.c:697
msgid "strtol error: number of blocks not specified"
msgstr ""

#: disk-utils/mkfs.minix.c:729
#, fuzzy, c-format
msgid "unable to open %s"
msgstr "Konnte %s nicht öffnen"

#: disk-utils/mkfs.minix.c:731
#, c-format
msgid "unable to stat %s"
msgstr ""

#: disk-utils/mkfs.minix.c:735
#, fuzzy, c-format
msgid "will not try to make filesystem on '%s'"
msgstr "Auf »%s« wird kein Dateisystem erzeugt"

#: disk-utils/mkswap.c:178
#, c-format
msgid "Bad user-specified page size %d\n"
msgstr ""

#: disk-utils/mkswap.c:187
#, c-format
msgid "Using user-specified page size %d, instead of the system values %d/%d\n"
msgstr ""

#: disk-utils/mkswap.c:191
#, fuzzy, c-format
msgid "Assuming pages of size %d (not %d)\n"
msgstr "Es wird eine Seitengröße von %d angenommen.\n"

#: disk-utils/mkswap.c:316
#, c-format
msgid "Usage: %s [-c] [-v0|-v1] [-pPAGESZ] /dev/name [blocks]\n"
msgstr "Aufruf: %s [-c] [-v0|-v1] [-pSEITENGRÖSSE] /dev/Name [Größe in kB]\n"

#: disk-utils/mkswap.c:339
msgid "too many bad pages"
msgstr "Zu viele beschädigte »Seiten«"

#: disk-utils/mkswap.c:353 misc-utils/look.c:182 misc-utils/setterm.c:1129
#: text-utils/more.c:1934 text-utils/more.c:1945
msgid "Out of memory"
msgstr "Speicher ist alle"

#: disk-utils/mkswap.c:370
msgid "one bad page\n"
msgstr "Eine beschädigte »Seite«\n"

#: disk-utils/mkswap.c:372
#, c-format
msgid "%d bad pages\n"
msgstr "%d beschädigte »Seiten«\n"

#: disk-utils/mkswap.c:492
#, c-format
msgid "%s: error: Nowhere to set up swap on?\n"
msgstr ""
"%s: Es wurde nicht angegeben, wo der Swapbereich angelegt werden soll.\n"

#: disk-utils/mkswap.c:510
#, c-format
msgid "%s: error: size %ld is larger than device size %d\n"
msgstr ""
"%s: Fehler: Die angegebene Größe %ld ist größer als die des Gerätes: %d\n"

#: disk-utils/mkswap.c:529
#, c-format
msgid "%s: error: unknown version %d\n"
msgstr "%s: Fehler: unbekannte Version %d\n"

#: disk-utils/mkswap.c:535
#, c-format
msgid "%s: error: swap area needs to be at least %ldkB\n"
msgstr "%s: Fehler: Der Swapbereich muss mindestens %ldkB groß sein\n"

#: disk-utils/mkswap.c:554
#, c-format
msgid "%s: warning: truncating swap area to %ldkB\n"
msgstr "%s: Warnung: Der Swapbereich wird nur mit der Größe %ldkB angelegt\n"

#: disk-utils/mkswap.c:566
#, c-format
msgid "Will not try to make swapdevice on '%s'"
msgstr ""

#: disk-utils/mkswap.c:575 disk-utils/mkswap.c:596
msgid "fatal: first page unreadable"
msgstr ""

#: disk-utils/mkswap.c:581
#, c-format
msgid ""
"%s: Device '%s' contains a valid Sun disklabel.\n"
"This probably means creating v0 swap would destroy your partition table\n"
"No swap created. If you really want to create swap v0 on that device, use\n"
"the -f option to force it.\n"
msgstr ""
"%s: Das Gerät %s enthält einen gültigen »Sun disklabel«.\n"
"Das bedeutet wahrscheinlich, dass das Anlegen eines v0-Swapbereiches die\n"
"Partitionstabelle zerstören wird.\n"
"Es wird kein Swapbereich angelegt. Wenn Sie wirklich einen Swapbereich\n"
"anlegen wollen, so benutzen Sie die -f Option.\n"

#: disk-utils/mkswap.c:605
msgid "Unable to set up swap-space: unreadable"
msgstr ""

#: disk-utils/mkswap.c:606
#, c-format
msgid "Setting up swapspace version %d, size = %ld bytes\n"
msgstr "Swapbereich Version %d mit der Größe %ld Bytes wird angelegt\n"

#: disk-utils/mkswap.c:612
msgid "unable to rewind swap-device"
msgstr ""

#: disk-utils/mkswap.c:615
msgid "unable to write signature page"
msgstr ""

#: disk-utils/mkswap.c:623
msgid "fsync failed"
msgstr ""

#: disk-utils/setfdprm.c:31
#, fuzzy, c-format
msgid "Invalid number: %s\n"
msgstr "Ungültige Nummer: %s\n"

#: disk-utils/setfdprm.c:81
#, fuzzy, c-format
msgid "Syntax error: '%s'\n"
msgstr "Syntaxfehler: »%s«\n"

#: disk-utils/setfdprm.c:91
#, c-format
msgid "No such parameter set: '%s'\n"
msgstr ""

#: disk-utils/setfdprm.c:101
#, fuzzy, c-format
msgid "   %s [ -p ] dev name\n"
msgstr "Aufruf: %s [ -n ] Gerät\n"

#: disk-utils/setfdprm.c:102
#, c-format
msgid ""
"   %s [ -p ] dev size sect heads tracks stretch gap rate spec1 fmt_gap\n"
msgstr ""

#: disk-utils/setfdprm.c:105
#, c-format
msgid "   %s [ -c | -y | -n | -d ] dev\n"
msgstr ""

#: disk-utils/setfdprm.c:107
#, c-format
msgid "   %s [ -c | -y | -n ] dev\n"
msgstr ""

# "Unbrauchbar"
#: fdisk/cfdisk.c:396 fdisk/cfdisk.c:1953
msgid "Unusable"
msgstr "Unbenutzbar"

#: fdisk/cfdisk.c:398 fdisk/cfdisk.c:1955
msgid "Free Space"
msgstr "Freier Bereich"

#: fdisk/cfdisk.c:401
msgid "Linux ext2"
msgstr "Linux ext2"

#: fdisk/cfdisk.c:403
#, fuzzy
msgid "Linux XFS"
msgstr "Linux"

#. also Solaris
#: fdisk/cfdisk.c:405 fdisk/i386_sys_types.c:57
msgid "Linux"
msgstr "Linux"

#: fdisk/cfdisk.c:408
msgid "OS/2 HPFS"
msgstr "OS/2 HPFS"

#: fdisk/cfdisk.c:410
msgid "OS/2 IFS"
msgstr "OS/2 IFS"

#: fdisk/cfdisk.c:414
msgid "NTFS"
msgstr "NTFS"

#: fdisk/cfdisk.c:425
msgid "Disk has been changed.\n"
msgstr "Festplatte wurde verändert.\n"

#: fdisk/cfdisk.c:426
msgid "Reboot the system to ensure the partition table is correctly updated.\n"
msgstr ""
"Rebooten Sie das System, um sicherzustellen, dass die Partitionstabelle neu "
"gelesen wird.\n"

#: fdisk/cfdisk.c:429
msgid ""
"\n"
"WARNING: If you have created or modified any\n"
"DOS 6.x partitions, please see the cfdisk manual\n"
"page for additional information.\n"
msgstr ""
"\n"
"WARNUNG: Wenn Sie eine DOS 6.x Partition angelegt\n"
"oder verändert haben, dann schauen Sie bitte in die\n"
"cfdisk-manual-Seite nach weiteren Informationen\n"

#: fdisk/cfdisk.c:524
msgid "FATAL ERROR"
msgstr "FATALER FEHLER"

#: fdisk/cfdisk.c:525
msgid "Press any key to exit cfdisk"
msgstr "Eine Taste drücken, um cfdisk zu beenden"

#: fdisk/cfdisk.c:572 fdisk/cfdisk.c:580
msgid "Cannot seek on disk drive"
msgstr "Konnte »seek()« nicht auf der Festplatte benutzen"

#: fdisk/cfdisk.c:574
msgid "Cannot read disk drive"
msgstr "Konnte nicht von der Festplatte lesen"

#: fdisk/cfdisk.c:582
msgid "Cannot write disk drive"
msgstr "Konnte nicht auf die Festplatte schreiben"

#: fdisk/cfdisk.c:850
msgid "Too many partitions"
msgstr "Zu viele Partitionen"

#: fdisk/cfdisk.c:855
msgid "Partition begins before sector 0"
msgstr "Partition fängt vor Sektor 0 an"

#: fdisk/cfdisk.c:860
msgid "Partition ends before sector 0"
msgstr "Partition endet vor Sektor 0"

#: fdisk/cfdisk.c:865
msgid "Partition begins after end-of-disk"
msgstr "Partition fängt hinter dem Ende der Festplatte an"

#: fdisk/cfdisk.c:870
msgid "Partition ends after end-of-disk"
msgstr "Partition endet hinter dem Ende der Festplatte"

#: fdisk/cfdisk.c:894
msgid "logical partitions not in disk order"
msgstr ""

#: fdisk/cfdisk.c:897
msgid "logical partitions overlap"
msgstr "Logische Partitionen überlappen"

#: fdisk/cfdisk.c:899
msgid "enlarged logical partitions overlap"
msgstr ""

#: fdisk/cfdisk.c:929
msgid ""
"!!!! Internal error creating logical drive with no extended partition !!!!"
msgstr ""
"!! Interner Fehler beim Erzeugen einer log. Part. ohne eine erw. Part. !!"

#: fdisk/cfdisk.c:940 fdisk/cfdisk.c:952
msgid ""
"Cannot create logical drive here -- would create two extended partitions"
msgstr ""
"Kann hier keine log. Part. anlegen -- eine zweite erw. müsste erzeugt werden."

#: fdisk/cfdisk.c:1100
msgid "Menu item too long. Menu may look odd."
msgstr "Menüeintrag ist zu lang. Das Menü könnte ungewöhnlich aussehen"

# "Ausrichtung" "Nehme horizontale Voreinstellung."
#: fdisk/cfdisk.c:1154
msgid "Menu without direction. Defaulting horizontal."
msgstr "Menü ohne Richtung, verwende horizontal."

#: fdisk/cfdisk.c:1284
msgid "Illegal key"
msgstr "Diese Taste ist hier nicht verwendbar"

#: fdisk/cfdisk.c:1307
msgid "Press a key to continue"
msgstr "Eine Taste drücken, um fortzufahren"

#: fdisk/cfdisk.c:1354 fdisk/cfdisk.c:1924 fdisk/cfdisk.c:2455
#: fdisk/cfdisk.c:2457
msgid "Primary"
msgstr "Primäre"

#: fdisk/cfdisk.c:1354
msgid "Create a new primary partition"
msgstr "Erzeuge eine neue primäre Partition"

#: fdisk/cfdisk.c:1355 fdisk/cfdisk.c:1924 fdisk/cfdisk.c:2454
#: fdisk/cfdisk.c:2457
msgid "Logical"
msgstr "Logische"

#: fdisk/cfdisk.c:1355
msgid "Create a new logical partition"
msgstr "Erzeuge eine neue logische Partition"

#: fdisk/cfdisk.c:1356 fdisk/cfdisk.c:1411 fdisk/cfdisk.c:2129
msgid "Cancel"
msgstr "Abbruch"

#: fdisk/cfdisk.c:1356 fdisk/cfdisk.c:1411
msgid "Don't create a partition"
msgstr "Erzeuge keine neue Partition"

#: fdisk/cfdisk.c:1372
msgid "!!! Internal error !!!"
msgstr "!!! Interner Fehler !!!"

#: fdisk/cfdisk.c:1375
msgid "Size (in MB): "
msgstr "Größe (in MB): "

#: fdisk/cfdisk.c:1409
msgid "Beginning"
msgstr "Anfang"

#: fdisk/cfdisk.c:1409
msgid "Add partition at beginning of free space"
msgstr "Erzeuge Partition am Anfang des freien Bereiches"

#: fdisk/cfdisk.c:1410
msgid "End"
msgstr "Ende"

#: fdisk/cfdisk.c:1410
msgid "Add partition at end of free space"
msgstr "Erzeuge Partition am Ende des freien Bereiches"

#: fdisk/cfdisk.c:1428
msgid "No room to create the extended partition"
msgstr "Kein Platz, um die erweiterte Partition anzulegen"

#: fdisk/cfdisk.c:1472
#, fuzzy
msgid "No partition table or unknown signature on partition table"
msgstr "Beschädigte Signatur in der Partitionstabelle"

#: fdisk/cfdisk.c:1474
msgid "Do you wish to start with a zero table [y/N] ?"
msgstr ""

#: fdisk/cfdisk.c:1526
msgid "You specified more cylinders than fit on disk"
msgstr "Sie haben mehr Zylinder angegeben, als auf die Festplatte passen"

# That's not a direct translation, but I've tried to be
# more informative.
#: fdisk/cfdisk.c:1556
msgid "Cannot open disk drive"
msgstr "Konnte nicht auf die Festplatte zugreifen"

# "Nur lesender Zugriff möglich - Sie haben keine Schreibberechtigung" (joey)
#: fdisk/cfdisk.c:1558 fdisk/cfdisk.c:1737
msgid "Opened disk read-only - you have no permission to write"
msgstr ""
"Platte wurde nur zum Lesen geöffnet - Sie haben keine Rechte zum Schreiben"

#: fdisk/cfdisk.c:1579
msgid "Cannot get disk size"
msgstr "Konnte die Größe der Festplatte nicht feststellen"

# "Ungültige primäre Partition"
#: fdisk/cfdisk.c:1604
msgid "Bad primary partition"
msgstr "Beschädigte primäre Partition"

#: fdisk/cfdisk.c:1634
msgid "Bad logical partition"
msgstr "Beschädigte logische Partition"

#: fdisk/cfdisk.c:1749
msgid "Warning!!  This may destroy data on your disk!"
msgstr "Warnung!!  Dies kann Daten auf der Festplatte zerstören!"

#: fdisk/cfdisk.c:1753
msgid "Are you sure you want write the partition table to disk? (yes or no): "
msgstr ""
"Sind Sie sicher, dass Sie die Partitionstabelle schreiben wollen? (ja/nein): "

#: fdisk/cfdisk.c:1759
msgid "no"
msgstr "nein"

#: fdisk/cfdisk.c:1760
msgid "Did not write partition table to disk"
msgstr "Die Partitionstabelle wurde nicht auf die Festplatte geschrieben"

#: fdisk/cfdisk.c:1762
msgid "yes"
msgstr "ja"

#: fdisk/cfdisk.c:1765
msgid "Please enter `yes' or `no'"
msgstr "Bitte »ja« oder »nein« eingeben"

#: fdisk/cfdisk.c:1769
msgid "Writing partition table to disk..."
msgstr "Die Partitionstabelle wird auf die Festplatte geschrieben..."

#: fdisk/cfdisk.c:1794 fdisk/cfdisk.c:1798
msgid "Wrote partition table to disk"
msgstr "Die Partitionstabelle wurde auf die Festplatte geschrieben"

# That's not a good translation, but I guess, I can't make it longer.
#: fdisk/cfdisk.c:1796
msgid ""
"Wrote partition table, but re-read table failed.  Reboot to update table."
msgstr ""
"Die Tabelle wurde geschr., aber das Neueinlesen schlug fehl.  Rebooten Sie."

# This one isn't realy correct.
#: fdisk/cfdisk.c:1806
#, fuzzy
msgid "No primary partitions are marked bootable. DOS MBR cannot boot this."
msgstr ""
"Mehrere Partitionen sind als bootbar markiert, der DOS MBR kann nicht booten."

# This one isn't realy correct.
#: fdisk/cfdisk.c:1808
#, fuzzy
msgid ""
"More than one primary partition is marked bootable. DOS MBR cannot boot this."
msgstr ""
"Mehrere Partitionen sind als bootbar markiert, der DOS MBR kann nicht booten."

# "Geben sie einen Dateinamen ein oder drücken Sie Return, um es auf dem Bildschirm anzuzeigen: "
# is too long
#: fdisk/cfdisk.c:1866 fdisk/cfdisk.c:1985 fdisk/cfdisk.c:2069
msgid "Enter filename or press RETURN to display on screen: "
msgstr "Dateiname oder Return um es auf dem Bildschirm anzuzeigen: "

#: fdisk/cfdisk.c:1875 fdisk/cfdisk.c:1993 fdisk/cfdisk.c:2077
#, c-format
msgid "Cannot open file '%s'"
msgstr "Konnte %s nicht öffnen"

#: fdisk/cfdisk.c:1886
#, c-format
msgid "Disk Drive: %s\n"
msgstr "Festplatte: %s\n"

#: fdisk/cfdisk.c:1888
msgid "Sector 0:\n"
msgstr "Sektor 0:\n"

#: fdisk/cfdisk.c:1895
#, c-format
msgid "Sector %d:\n"
msgstr "Sektor %d:\n"

#: fdisk/cfdisk.c:1915
msgid "   None   "
msgstr "   Keine  "

#: fdisk/cfdisk.c:1917
msgid "   Pri/Log"
msgstr "   Pri/Log"

#: fdisk/cfdisk.c:1919
msgid "   Primary"
msgstr "   Primäre"

#: fdisk/cfdisk.c:1921
msgid "   Logical"
msgstr "  Logische"

#. odd flag on end
#. type id
#. type name
#: fdisk/cfdisk.c:1959 fdisk/fdisk.c:1275 fdisk/fdisk.c:1563
#: fdisk/fdisksgilabel.c:238 fdisk/fdisksunlabel.c:691 fdisk/sfdisk.c:582
msgid "Unknown"
msgstr "Unbekannt"

#: fdisk/cfdisk.c:1965
#, c-format
msgid "Boot (%02X)"
msgstr "Boot (%02X)"

#: fdisk/cfdisk.c:1967 fdisk/cfdisk.c:2463
#, c-format
msgid "Unknown (%02X)"
msgstr "Unbekannt (%02X)"

#: fdisk/cfdisk.c:1969
#, c-format
msgid "None (%02X)"
msgstr "Keine (%02X)"

#: fdisk/cfdisk.c:2004 fdisk/cfdisk.c:2088
#, c-format
msgid "Partition Table for %s\n"
msgstr "Partitionstabelle von %s\n"

#: fdisk/cfdisk.c:2006
msgid "            First    Last\n"
msgstr "            Erster   Letzter\n"

#: fdisk/cfdisk.c:2007
msgid ""
" # Type     Sector   Sector   Offset  Length   Filesystem Type (ID)   Flags\n"
msgstr ""
" # Typ      Sektor   Sektor   Offset  Länge    Dateisystemtyp (ID)    Flags\n"

#: fdisk/cfdisk.c:2008
msgid ""
"-- ------- -------- --------- ------ --------- ---------------------- "
"---------\n"
msgstr ""
"-- ------- -------- --------- ------ --------- ---------------------- "
"---------\n"

#. Three-line heading. Read "Start Sector" etc vertically.
#: fdisk/cfdisk.c:2091
msgid "         ---Starting---      ----Ending----    Start Number of\n"
msgstr "         ---Anfangs----      -----End------   Start  Anzahl der\n"

#: fdisk/cfdisk.c:2092
msgid " # Flags Head Sect Cyl   ID  Head Sect Cyl    Sector  Sectors\n"
msgstr " # Flags Kopf Sekt Zyl.  ID  Kopf Sekt Zyl    Sektor  Sektoren\n"

#: fdisk/cfdisk.c:2093
msgid "-- ----- ---- ---- ---- ---- ---- ---- ---- -------- ---------\n"
msgstr "-- ----- ---- ---- ---- ---- ---- ---- ---- -------- ---------\n"

#: fdisk/cfdisk.c:2126
#, fuzzy
msgid "Raw"
msgstr "\"Roh\""

#: fdisk/cfdisk.c:2126
#, fuzzy
msgid "Print the table using raw data format"
msgstr "Die \"rohen\" Daten der Tabelle ausgeben"

#: fdisk/cfdisk.c:2127 fdisk/cfdisk.c:2229
msgid "Sectors"
msgstr "Sektoren"

#: fdisk/cfdisk.c:2127
msgid "Print the table ordered by sectors"
msgstr "Die Tabelle nach Sektoren sortiert ausgeben"

#: fdisk/cfdisk.c:2128
msgid "Table"
msgstr "Tabelle"

# "Nur die Partitionstabelle ausgeben" (joey)
#: fdisk/cfdisk.c:2128
msgid "Just print the partition table"
msgstr "Einfach die Tabelle ausgeben"

#: fdisk/cfdisk.c:2129
msgid "Don't print the table"
msgstr "Zeige die Tabelle nicht an"

#: fdisk/cfdisk.c:2157
msgid "Help Screen for cfdisk"
msgstr "Hilfe für cfdisk"

#: fdisk/cfdisk.c:2159
msgid "This is cfdisk, a curses based disk partitioning program, which"
msgstr "Dies ist cfdisk, ein Programm das curses benutzt und es ihnen"

#: fdisk/cfdisk.c:2160
msgid "allows you to create, delete and modify partitions on your hard"
msgstr "erlaubt, auf Ihren Festplatten Partitionen anzulegen, zu löschen"

#: fdisk/cfdisk.c:2161
msgid "disk drive."
msgstr "und zu verändern."

#: fdisk/cfdisk.c:2163
msgid "Copyright (C) 1994-1999 Kevin E. Martin & aeb"
msgstr "Copyright (C) 1994-1999 Kevin E. Martin & aeb"

# "Befehl"
#: fdisk/cfdisk.c:2165
msgid "Command      Meaning"
msgstr "Befehl     Bedeutung"

#: fdisk/cfdisk.c:2166
msgid "-------      -------"
msgstr "--------     ---------"

# "  b          Wechselt zwischen bootfähig und nicht bootfähig."
#: fdisk/cfdisk.c:2167
msgid "  b          Toggle bootable flag of the current partition"
msgstr "  b          (De)Aktivieren des bootbar-flags der aktuellen Partition"

#: fdisk/cfdisk.c:2168
msgid "  d          Delete the current partition"
msgstr "  d          Die aktuelle Partition löschen"

#: fdisk/cfdisk.c:2169
msgid "  g          Change cylinders, heads, sectors-per-track parameters"
msgstr ""
"  g          Die Anzahl der Zylinder, Köpfe und Sektoren pro Spur ändern"

#: fdisk/cfdisk.c:2170
msgid "             WARNING: This option should only be used by people who"
msgstr "             WARNUNG: Diese Funktion sollte nur von Leuten benutzt"

#: fdisk/cfdisk.c:2171
msgid "             know what they are doing."
msgstr "             werden, die wissen, was sie tun."

#: fdisk/cfdisk.c:2172
msgid "  h          Print this screen"
msgstr "  h          Diese Hilfe anzeigen"

#: fdisk/cfdisk.c:2173
msgid "  m          Maximize disk usage of the current partition"
msgstr "  m          Maximieren der Nutzung der aktuellen Partition"

#: fdisk/cfdisk.c:2174
msgid "             Note: This may make the partition incompatible with"
msgstr ""
"             Beachten Sie, dass dies die Partition nicht mehr kompatibel"

#: fdisk/cfdisk.c:2175
msgid "             DOS, OS/2, ..."
msgstr "             zu DOS, OS/2, ... machen kann"

#: fdisk/cfdisk.c:2176
msgid "  n          Create new partition from free space"
msgstr "  n          Aus dem freien Bereich eine neue Partition erzeugen"

#: fdisk/cfdisk.c:2177
msgid "  p          Print partition table to the screen or to a file"
msgstr ""
"  p          Die Partitionstab. auf dem Bildschirm oder in eine Datei "
"ausgeben"

# "verschiedene"
#: fdisk/cfdisk.c:2178
msgid "             There are several different formats for the partition"
msgstr "             Es gibt mehrere Formate für die Partitionstabelle, aus"

#: fdisk/cfdisk.c:2179
msgid "             that you can choose from:"
msgstr "             denen man wählen kann"

#: fdisk/cfdisk.c:2180
msgid "                r - Raw data (exactly what would be written to disk)"
msgstr ""
"                r - »Rohe« Daten (was auf die Festplatte geschrieben würde)"

#: fdisk/cfdisk.c:2181
msgid "                s - Table ordered by sectors"
msgstr "                s - Tabelle nach Sektoren sortiert"

#: fdisk/cfdisk.c:2182
msgid "                t - Table in raw format"
msgstr "                t - Tabelle mit den reinen Daten"

#: fdisk/cfdisk.c:2183
msgid "  q          Quit program without writing partition table"
msgstr ""
"  q          Das Programm beenden ohne die Partitionstabelle zu schreiben"

#: fdisk/cfdisk.c:2184
msgid "  t          Change the filesystem type"
msgstr "  t          Den Dateisystemtyp ändern"

#: fdisk/cfdisk.c:2185
msgid "  u          Change units of the partition size display"
msgstr "  u          Einheit für die Größenanzeige ändern"

#: fdisk/cfdisk.c:2186
msgid "             Rotates through MB, sectors and cylinders"
msgstr "             Wechselt zwischen MB, Sektoren und Zylindern"

#: fdisk/cfdisk.c:2187
msgid "  W          Write partition table to disk (must enter upper case W)"
msgstr ""
"  W          Die Partitionstabelle auf die Festplatte schreiben (großes W)"

# or "Da dieses ..." ?
#: fdisk/cfdisk.c:2188
msgid "             Since this might destroy data on the disk, you must"
msgstr "             Da dies Daten auf der Festplatte zerstören kann, müssen"

#: fdisk/cfdisk.c:2189
msgid "             either confirm or deny the write by entering `yes' or"
msgstr "             Sie das Schreiben mit »yes« oder »no« bestätigen oder"

#: fdisk/cfdisk.c:2190
msgid "             `no'"
msgstr "             ablehnen"

#: fdisk/cfdisk.c:2191
msgid "Up Arrow     Move cursor to the previous partition"
msgstr "Pfeil-hoch   Den Cursor zur vorherigen Partition bewegen"

#: fdisk/cfdisk.c:2192
msgid "Down Arrow   Move cursor to the next partition"
msgstr "Pfeil-runter Den Cursor zur nächsten Partition bewegen"

# "Strg" ?
# "Baut den Bildschirm neu auf"
#: fdisk/cfdisk.c:2193
msgid "CTRL-L       Redraws the screen"
msgstr "Ctrl-L       Zeichnet den Bildschirm erneut"

#: fdisk/cfdisk.c:2194
msgid "  ?          Print this screen"
msgstr "  ?          Diese Hilfe anzeigen"

# "Hinweis"
#: fdisk/cfdisk.c:2196
msgid "Note: All of the commands can be entered with either upper or lower"
msgstr "Hinweis: Alle Befehle können mit Klein- oder Großbuchstaben "

#: fdisk/cfdisk.c:2197
msgid "case letters (except for Writes)."
msgstr "eingegeben werden (außer W zum Schreiben)."

#: fdisk/cfdisk.c:2227 fdisk/cfdisk.c:2549 fdisk/fdisksunlabel.c:321
#: fdisk/fdisksunlabel.c:323
msgid "Cylinders"
msgstr " Zylinder"

#: fdisk/cfdisk.c:2227
msgid "Change cylinder geometry"
msgstr "Die Anzahl der Zylinder ändern"

#: fdisk/cfdisk.c:2228 fdisk/fdisksunlabel.c:318
msgid "Heads"
msgstr "Köpfe"

#: fdisk/cfdisk.c:2228
msgid "Change head geometry"
msgstr "Die Anzahl der Köpfe ändern"

#: fdisk/cfdisk.c:2229
msgid "Change sector geometry"
msgstr "Die Anzahl der Sektoren pro Spur ändern"

#: fdisk/cfdisk.c:2230
msgid "Done"
msgstr "Fertig"

#: fdisk/cfdisk.c:2230
msgid "Done with changing geometry"
msgstr "Ändern der Geometrie beenden"

#: fdisk/cfdisk.c:2243
msgid "Enter the number of cylinders: "
msgstr "Geben Sie die Anzahl der Zylinder ein: "

#: fdisk/cfdisk.c:2255 fdisk/cfdisk.c:2817
msgid "Illegal cylinders value"
msgstr "Ungültiger Wert für die Anzahl der Zylinder"

#: fdisk/cfdisk.c:2261
msgid "Enter the number of heads: "
msgstr "Geben Sie die Anzahl der Köpfe ein: "

#: fdisk/cfdisk.c:2268 fdisk/cfdisk.c:2827
msgid "Illegal heads value"
msgstr "Ungültiger Wert für die Anzahl der Köpfe"

#: fdisk/cfdisk.c:2274
msgid "Enter the number of sectors per track: "
msgstr "Geben Sie die Anzahl der Sektoren pro Spur ein: "

#: fdisk/cfdisk.c:2281 fdisk/cfdisk.c:2834
msgid "Illegal sectors value"
msgstr "Ungültiger Wert für die Anzahl der Sektoren"

#: fdisk/cfdisk.c:2384
msgid "Enter filesystem type: "
msgstr "Geben Sie den Dateisystemtyp ein: "

#: fdisk/cfdisk.c:2402
msgid "Cannot change FS Type to empty"
msgstr "Der Dateisystemtyp kann nicht auf »leer« gesetzt werden"

#: fdisk/cfdisk.c:2404
msgid "Cannot change FS Type to extended"
msgstr "Der Dateisystemtyp kann nicht auf »erweitert« gesetzt werden"

#: fdisk/cfdisk.c:2432 fdisk/fdisksunlabel.c:44
msgid "Boot"
msgstr "Boot"

#: fdisk/cfdisk.c:2434
#, c-format
msgid "Unk(%02X)"
msgstr "Unb(%02X)"

#: fdisk/cfdisk.c:2437 fdisk/cfdisk.c:2440
msgid ", NC"
msgstr ", NC"

#: fdisk/cfdisk.c:2445 fdisk/cfdisk.c:2448
msgid "NC"
msgstr "NC"

#: fdisk/cfdisk.c:2456
msgid "Pri/Log"
msgstr "Pri/Log"

#: fdisk/cfdisk.c:2532
#, c-format
msgid "Disk Drive: %s"
msgstr "Festplatte: %s"

#: fdisk/cfdisk.c:2535
#, c-format
msgid "Size: %lld bytes"
msgstr "Größe: %lld Bytes"

#: fdisk/cfdisk.c:2537
#, c-format
msgid "Heads: %d   Sectors per Track: %d   Cylinders: %d"
msgstr "Köpfe: %d   Sektoren pro Spur: %d   Zylinder: %d"

#: fdisk/cfdisk.c:2541
msgid "Name"
msgstr "Name"

# I currently don't know a better translation
#: fdisk/cfdisk.c:2542
msgid "Flags"
msgstr "Flags"

#: fdisk/cfdisk.c:2543
msgid "Part Type"
msgstr "Part. Typ"

#: fdisk/cfdisk.c:2544
msgid "FS Type"
msgstr "Dateisystemtyp"

#: fdisk/cfdisk.c:2545
msgid "[Label]"
msgstr "[Bezeichner]"

#: fdisk/cfdisk.c:2547
msgid "  Sectors"
msgstr " Sektoren"

#: fdisk/cfdisk.c:2551
msgid "Size (MB)"
msgstr "Größe (MB)"

#: fdisk/cfdisk.c:2553
msgid "Size (GB)"
msgstr "Größe (GB)"

#: fdisk/cfdisk.c:2608
msgid "Bootable"
msgstr "Bootbar"

# "Bootfähigkeit der aktuellen Partition ändern" (joey)
#: fdisk/cfdisk.c:2608
msgid "Toggle bootable flag of the current partition"
msgstr "(De)Aktivieren des bootbar-flags der aktuellen Partition"

# "Löschen"
#: fdisk/cfdisk.c:2609
msgid "Delete"
msgstr "Löschen"

#: fdisk/cfdisk.c:2609
msgid "Delete the current partition"
msgstr "Die aktuelle Partition löschen"

#: fdisk/cfdisk.c:2610
msgid "Geometry"
msgstr "Geometrie"

#: fdisk/cfdisk.c:2610
msgid "Change disk geometry (experts only)"
msgstr "Die Festplattengeometrieparameter ändern (nur für Experten)"

#: fdisk/cfdisk.c:2611
msgid "Help"
msgstr "Hilfe"

#: fdisk/cfdisk.c:2611
msgid "Print help screen"
msgstr "Die Hilfe anzeigen"

#: fdisk/cfdisk.c:2612
msgid "Maximize"
msgstr "Maxim."

#: fdisk/cfdisk.c:2612
msgid "Maximize disk usage of the current partition (experts only)"
msgstr "Maximieren der Nutzung der aktuellen Partition (nur für Experten)"

#: fdisk/cfdisk.c:2613
msgid "New"
msgstr "Neue"

# "Erzeuge aus dem freien Bereich eine neue Partition"
#: fdisk/cfdisk.c:2613
msgid "Create new partition from free space"
msgstr "Neue Partition im freiem Bereich anlegen"

#: fdisk/cfdisk.c:2614
msgid "Print"
msgstr "Ausgabe"

# "Gib die Partitionstabelle auf dem Bildschirm oder in eine Datei aus"
#: fdisk/cfdisk.c:2614
msgid "Print partition table to the screen or to a file"
msgstr "Partitionstabelle auf dem Bildschirm oder in Datei ausgeben"

#: fdisk/cfdisk.c:2615
msgid "Quit"
msgstr "Ende"

# "Beende das Programm ohne die Partitionstabelle zu schreiben"
#: fdisk/cfdisk.c:2615
msgid "Quit program without writing partition table"
msgstr "Das Programm beenden, ohne die Partitionstabelle zu speichern"

#: fdisk/cfdisk.c:2616
msgid "Type"
msgstr "Typ"

#: fdisk/cfdisk.c:2616
msgid "Change the filesystem type (DOS, Linux, OS/2 and so on)"
msgstr "Den Dateisystemtyp (DOS, Linux, OS/2, etc.)"

# Maybe without the dot.
#: fdisk/cfdisk.c:2617
msgid "Units"
msgstr "Einheit."

# "Ändert die Einheiten der Größenanzeige ("
#: fdisk/cfdisk.c:2617
msgid "Change units of the partition size display (MB, sect, cyl)"
msgstr ""
"Zwischen den Einheiten für die Größenanzeige wechseln (MB, Sekt., Zyl.)"

#: fdisk/cfdisk.c:2618
msgid "Write"
msgstr "Schreib."

#: fdisk/cfdisk.c:2618
msgid "Write partition table to disk (this might destroy data)"
msgstr "Die Partitionstabelle schreiben (dies kann Daten zerstören)"

#: fdisk/cfdisk.c:2664
msgid "Cannot make this partition bootable"
msgstr "Diese Partition kann nicht als bootbar markiert werden"

#: fdisk/cfdisk.c:2674
msgid "Cannot delete an empty partition"
msgstr "Eine leere Partition kann nicht gelöscht werden"

#: fdisk/cfdisk.c:2694 fdisk/cfdisk.c:2696
msgid "Cannot maximize this partition"
msgstr "Die Nutzung dieser Partition kann nicht maximiert werden"

#: fdisk/cfdisk.c:2704
msgid "This partition is unusable"
msgstr "Diese Partition ist unbenutzbar"

#: fdisk/cfdisk.c:2706
msgid "This partition is already in use"
msgstr "Diese Partition ist bereits in Benutzung"

#: fdisk/cfdisk.c:2723
msgid "Cannot change the type of an empty partition"
msgstr "Der Dateisystemtyp einer leeren Partition kann nicht geändert werden"

#: fdisk/cfdisk.c:2750 fdisk/cfdisk.c:2756
msgid "No more partitions"
msgstr "Keine weiteren Partitionen"

# "Ungültige Taste"
#: fdisk/cfdisk.c:2763
msgid "Illegal command"
msgstr "Unzulässiger Befehl"

#: fdisk/cfdisk.c:2773
msgid "Copyright (C) 1994-2000 Kevin E. Martin & aeb\n"
msgstr "Copyright (C) 1994-2000 Kevin E. Martin & aeb\n"

#. Unfortunately, xgettext does not handle multi-line strings
#. so, let's use explicit \n's instead
#: fdisk/cfdisk.c:2780
#, c-format
msgid ""
"\n"
"Usage:\n"
"Print version:\n"
"        %s -v\n"
"Print partition table:\n"
"        %s -P {r|s|t} [options] device\n"
"Interactive use:\n"
"        %s [options] device\n"
"\n"
"Options:\n"
"-a: Use arrow instead of highlighting;\n"
"-z: Start with a zero partition table, instead of reading the pt from disk;\n"
"-c C -h H -s S: Override the kernel's idea of the number of cylinders,\n"
"                the number of heads and the number of sectors/track.\n"
"\n"
msgstr ""
"\n"
"Aufruf:\n"
"Ausgabe der Version:\n"
"        %s -v\n"
"Ausgabe der Partitionstabelle:\n"
"        %s -P {r|s|t} [Optionen] GERÄTEDATEI\n"
"Interaktive Benutzung:\n"
"        %s [Optionen] GERÄTEDATEI\n"
"\n"
"Optionen:\n"
"-a: Use arrow instead of highlighting;\n"
"-z: Start with a zero partition table, instead of reading the pt from disk;\n"
"-c C -h H -s S: Override the kernel's idea of the number of cylinders,\n"
"                the number of heads and the number of sectors/track.\n"
"\n"

#: fdisk/fdisk.c:193
#, fuzzy
msgid ""
"Usage: fdisk [-b SSZ] [-u] DISK     Change partition table\n"
"       fdisk -l [-b SSZ] [-u] DISK  List partition table(s)\n"
"       fdisk -s PARTITION           Give partition size(s) in blocks\n"
"       fdisk -v                     Give fdisk version\n"
"Here DISK is something like /dev/hdb or /dev/sda\n"
"and PARTITION is something like /dev/hda7\n"
"-u: give Start and End in sector (instead of cylinder) units\n"
"-b 2048: (for certain MO disks) use 2048-byte sectors\n"
msgstr ""
"Aufruf: fdisk [-b SSZ] [-u] Festplatte     Partitionstabelle bearbeiten\n"
"        fdisk -l [-b SSZ] [-u] Festplatte  Partitionstabelle ausgeben\n"
"        fdisk -s Partition                 Größe einer Partition in Blöcken\n"
"        fdisk -v                           Version anzeigen\n"
"\n"
"Festplatte ist zum Beispiel /dev/hda oder /dev/sda\n"
"Partition ist zum Beispiel /dev/hda7\n"
"\n"
"-u: Anfang und Ende werden in Sektoren statt in Zylindern angegeben\n"
"-b 2048: (bestimmte MO-Geräte) benutze 2048 Byte Sektoren\n"

#: fdisk/fdisk.c:205
msgid ""
"Usage: fdisk [-l] [-b SSZ] [-u] device\n"
"E.g.: fdisk /dev/hda  (for the first IDE disk)\n"
"  or: fdisk /dev/sdc  (for the third SCSI disk)\n"
"  or: fdisk /dev/eda  (for the first PS/2 ESDI drive)\n"
"  or: fdisk /dev/rd/c0d0  or: fdisk /dev/ida/c0d0  (for RAID devices)\n"
"  ...\n"
msgstr ""
"Aufruf: fdisk [-l] [-b SSZ] [-u] Gerät\n"
"Zum Beispiel: fdisk /dev/hda       (die erste IDE-Festplatte)\n"
"        oder: fdisk /dev/sdc       (die dritte SCSI-Festplatte)\n"
"        oder: fdisk /dev/eda       (die erste PS/2 ESDI-Festplatte)\n"
"        oder: fdisk /dev/rd/c0d0\n"
"        oder: fdisk /dev/ida/c0d0  (RAID-Festplatten)\n"
"        ...\n"

#: fdisk/fdisk.c:214
#, c-format
msgid "Unable to open %s\n"
msgstr "Konnte %s nicht öffnen\n"

#: fdisk/fdisk.c:218
#, c-format
msgid "Unable to read %s\n"
msgstr "Konnte %s nicht lesen\n"

# "Konnte in %s nicht positionieren"
#: fdisk/fdisk.c:222
#, c-format
msgid "Unable to seek on %s\n"
msgstr ""

#: fdisk/fdisk.c:226
#, c-format
msgid "Unable to write %s\n"
msgstr "Konnte %s nicht schreiben\n"

#: fdisk/fdisk.c:230
#, c-format
msgid "BLKGETSIZE ioctl failed on %s\n"
msgstr ""

#: fdisk/fdisk.c:234
msgid "Unable to allocate any more memory\n"
msgstr "Konnte keinen weiteren Speicher reservieren\n"

#: fdisk/fdisk.c:237
msgid "Fatal error\n"
msgstr "Fataler Fehler\n"

#: fdisk/fdisk.c:321 fdisk/fdisk.c:340 fdisk/fdisk.c:358 fdisk/fdisk.c:365
#: fdisk/fdisk.c:388 fdisk/fdisk.c:406 fdisk/fdisk.c:422 fdisk/fdisk.c:438
#: fdisk/fdiskbsdlabel.c:126
msgid "Command action"
msgstr "Befehl  Bedeutung"

#: fdisk/fdisk.c:322
msgid "   a   toggle a read only flag"
msgstr ""

#. sun
#: fdisk/fdisk.c:323 fdisk/fdisk.c:367
msgid "   b   edit bsd disklabel"
msgstr "   b   »bsd disklabel« bearbeiten"

#: fdisk/fdisk.c:324
msgid "   c   toggle the mountable flag"
msgstr ""

#. sun
#: fdisk/fdisk.c:325 fdisk/fdisk.c:344 fdisk/fdisk.c:369
msgid "   d   delete a partition"
msgstr "   d   Eine Partition löschen"

#: fdisk/fdisk.c:326 fdisk/fdisk.c:345 fdisk/fdisk.c:370
msgid "   l   list known partition types"
msgstr "   l   Die bekannten Dateisystemtypen anzeigen"

#. sun
#: fdisk/fdisk.c:327 fdisk/fdisk.c:346 fdisk/fdisk.c:359 fdisk/fdisk.c:371
#: fdisk/fdisk.c:396 fdisk/fdisk.c:413 fdisk/fdisk.c:429 fdisk/fdisk.c:446
#: fdisk/fdiskbsdlabel.c:131
msgid "   m   print this menu"
msgstr "   m   Dieses Menü anzeigen"

#: fdisk/fdisk.c:328 fdisk/fdisk.c:347 fdisk/fdisk.c:372
msgid "   n   add a new partition"
msgstr "   n   Eine neue Partition anlegen"

#: fdisk/fdisk.c:329 fdisk/fdisk.c:348 fdisk/fdisk.c:360 fdisk/fdisk.c:373
msgid "   o   create a new empty DOS partition table"
msgstr "   o   Eine neue leere DOS Partitionstabelle anlegen"

#: fdisk/fdisk.c:330 fdisk/fdisk.c:349 fdisk/fdisk.c:374 fdisk/fdisk.c:397
#: fdisk/fdisk.c:414 fdisk/fdisk.c:430 fdisk/fdisk.c:447
msgid "   p   print the partition table"
msgstr "   p   Die Partitionstabelle anzeigen"

#: fdisk/fdisk.c:331 fdisk/fdisk.c:350 fdisk/fdisk.c:361 fdisk/fdisk.c:375
#: fdisk/fdisk.c:398 fdisk/fdisk.c:415 fdisk/fdisk.c:431 fdisk/fdisk.c:448
#: fdisk/fdiskbsdlabel.c:134
msgid "   q   quit without saving changes"
msgstr "   q   Ende ohne Speichern der Änderungen"

#: fdisk/fdisk.c:332 fdisk/fdisk.c:351 fdisk/fdisk.c:362 fdisk/fdisk.c:376
msgid "   s   create a new empty Sun disklabel"
msgstr "   s   Einen neuen leeren »Sun disklabel« anlegen"

#. sun
#: fdisk/fdisk.c:333 fdisk/fdisk.c:352 fdisk/fdisk.c:377
msgid "   t   change a partition's system id"
msgstr "   t   Den Dateisystemtyp einer Partition ändern"

#: fdisk/fdisk.c:334 fdisk/fdisk.c:353 fdisk/fdisk.c:378
msgid "   u   change display/entry units"
msgstr "   u   Die Einheit für die Anzeige/Eingabe ändern"

#: fdisk/fdisk.c:335 fdisk/fdisk.c:354 fdisk/fdisk.c:379 fdisk/fdisk.c:401
#: fdisk/fdisk.c:418 fdisk/fdisk.c:434 fdisk/fdisk.c:451
msgid "   v   verify the partition table"
msgstr "   v   Die Partitionstabelle überprüfen"

#: fdisk/fdisk.c:336 fdisk/fdisk.c:355 fdisk/fdisk.c:380 fdisk/fdisk.c:402
#: fdisk/fdisk.c:419 fdisk/fdisk.c:435 fdisk/fdisk.c:452
msgid "   w   write table to disk and exit"
msgstr ""
"   w   Die Tabelle auf die Festplatte schreiben und das Programm beenden"

#: fdisk/fdisk.c:337 fdisk/fdisk.c:381
msgid "   x   extra functionality (experts only)"
msgstr "   x   Zusätzliche Funktionen (nur für Experten)"

#: fdisk/fdisk.c:341
msgid "   a   select bootable partition"
msgstr "   a   Wählen der bootbaren Partition"

#. sgi flavour
#: fdisk/fdisk.c:342
msgid "   b   edit bootfile entry"
msgstr "   b   Bearbeiten des »bootfile«-Eintrags"

#. sgi
#: fdisk/fdisk.c:343
msgid "   c   select sgi swap partition"
msgstr "   c   Die sgi swap Partition auswählen"

#: fdisk/fdisk.c:366
msgid "   a   toggle a bootable flag"
msgstr "   a   (De)Aktivieren des bootbar-Flags"

#: fdisk/fdisk.c:368
msgid "   c   toggle the dos compatibility flag"
msgstr "   c   (De)Aktivieren des DOS Kompatibilitätsflags"

#: fdisk/fdisk.c:389
msgid "   a   change number of alternate cylinders"
msgstr ""

#. sun
#: fdisk/fdisk.c:390 fdisk/fdisk.c:408 fdisk/fdisk.c:424 fdisk/fdisk.c:440
msgid "   c   change number of cylinders"
msgstr "   c   Die Anzahl der Zylinder ändern"

# XXX
#: fdisk/fdisk.c:391 fdisk/fdisk.c:409 fdisk/fdisk.c:425 fdisk/fdisk.c:441
msgid "   d   print the raw data in the partition table"
msgstr "   d   Zeige die »raw« Daten der Partitionstabelle an"

#: fdisk/fdisk.c:392
msgid "   e   change number of extra sectors per cylinder"
msgstr ""

#. sun
#: fdisk/fdisk.c:393 fdisk/fdisk.c:412 fdisk/fdisk.c:428 fdisk/fdisk.c:445
msgid "   h   change number of heads"
msgstr "   h   Die Anzahl der Köpfe ändern"

#: fdisk/fdisk.c:394
msgid "   i   change interleave factor"
msgstr ""

#. sun
#: fdisk/fdisk.c:395
msgid "   o   change rotation speed (rpm)"
msgstr ""

#: fdisk/fdisk.c:399 fdisk/fdisk.c:416 fdisk/fdisk.c:432 fdisk/fdisk.c:449
#: fdisk/fdiskbsdlabel.c:135
msgid "   r   return to main menu"
msgstr "   r   Zurück zum Hauptmenü"

#: fdisk/fdisk.c:400 fdisk/fdisk.c:417 fdisk/fdisk.c:433 fdisk/fdisk.c:450
msgid "   s   change number of sectors/track"
msgstr "   s   Die Anzahl der Sektoren/Spur ändern"

#: fdisk/fdisk.c:403
msgid "   y   change number of physical cylinders"
msgstr ""

#: fdisk/fdisk.c:407 fdisk/fdisk.c:423 fdisk/fdisk.c:439
msgid "   b   move beginning of data in a partition"
msgstr "   b   Den Datenanfang einer Partition verschieben"

# XXX - Or should this be "logical" instead of "extended" ?
#: fdisk/fdisk.c:410 fdisk/fdisk.c:426 fdisk/fdisk.c:442
msgid "   e   list extended partitions"
msgstr "   e   Erweiterte Partitionen anzeigen"

#. !sun
#: fdisk/fdisk.c:411 fdisk/fdisk.c:427 fdisk/fdisk.c:444
#, fuzzy
msgid "   g   create an IRIX (SGI) partition table"
msgstr "   g   Eine IRIX-Partitionstabelle anlegen"

#. !sun
#: fdisk/fdisk.c:443
msgid "   f   fix partition order"
msgstr ""

#: fdisk/fdisk.c:558
msgid "You must set"
msgstr ""

#: fdisk/fdisk.c:572
msgid "heads"
msgstr "Köpfe"

#: fdisk/fdisk.c:574 fdisk/fdisk.c:1110 fdisk/sfdisk.c:865
msgid "sectors"
msgstr "Sektoren"

#: fdisk/fdisk.c:576 fdisk/fdisk.c:1110 fdisk/fdiskbsdlabel.c:466
#: fdisk/sfdisk.c:865
msgid "cylinders"
msgstr "Zylinder"

#: fdisk/fdisk.c:580
#, c-format
msgid ""
"%s%s.\n"
"You can do this from the extra functions menu.\n"
msgstr ""
"%s%s.\n"
"Sie können dies im Zusatzfunktionsmenü tun.\n"

#: fdisk/fdisk.c:581
msgid " and "
msgstr " und "

#: fdisk/fdisk.c:598
#, c-format
msgid ""
"\n"
"The number of cylinders for this disk is set to %d.\n"
"There is nothing wrong with that, but this is larger than 1024,\n"
"and could in certain setups cause problems with:\n"
"1) software that runs at boot time (e.g., old versions of LILO)\n"
"2) booting and partitioning software from other OSs\n"
"   (e.g., DOS FDISK, OS/2 FDISK)\n"
msgstr ""

#: fdisk/fdisk.c:621
msgid "Bad offset in primary extended partition\n"
msgstr ""

#: fdisk/fdisk.c:635
#, c-format
msgid "Warning: deleting partitions after %d\n"
msgstr ""

#: fdisk/fdisk.c:652
#, c-format
msgid "Warning: extra link pointer in partition table %d\n"
msgstr ""

#: fdisk/fdisk.c:660
#, c-format
msgid "Warning: ignoring extra data in partition table %d\n"
msgstr ""

#: fdisk/fdisk.c:705
msgid ""
"Building a new DOS disklabel. Changes will remain in memory only,\n"
"until you decide to write them. After that, of course, the previous\n"
"content won't be recoverable.\n"
"\n"
msgstr ""

#: fdisk/fdisk.c:750
#, c-format
msgid "Note: sector size is %d (not %d)\n"
msgstr "Hinweis: Die Sektorgröße ist %d (nicht %d)\n"

# XXX
#: fdisk/fdisk.c:838
msgid "You will not be able to write the partition table.\n"
msgstr "Sie werden die Partitionstabelle nicht schreiben können.\n"

#: fdisk/fdisk.c:871
#, fuzzy
msgid ""
"Device contains neither a valid DOS partition table, nor Sun, SGI or OSF "
"disklabel\n"
msgstr ""
"Das Gerät enthält weder eine gültige DOS-Partitionstabelle,\n"
"noch einen Sun oder »SGI disklabel«\n"

#: fdisk/fdisk.c:888
msgid "Internal error\n"
msgstr "Interner Fehler\n"

#: fdisk/fdisk.c:910
#, c-format
msgid "Ignoring extra extended partition %d\n"
msgstr "Ignoriere die zusätzliche erweiterte Partition %d\n"

#: fdisk/fdisk.c:922
#, c-format
msgid ""
"Warning: invalid flag 0x%04x of partition table %d will be corrected by w"
"(rite)\n"
msgstr ""

#: fdisk/fdisk.c:944
msgid ""
"\n"
"got EOF thrice - exiting..\n"
msgstr ""

#: fdisk/fdisk.c:983
msgid "Hex code (type L to list codes): "
msgstr "Hex code (L um eine Liste anzuzeigen): "

#: fdisk/fdisk.c:1022
#, c-format
msgid "%s (%d-%d, default %d): "
msgstr "%s (%d-%d) [Standardwert: %d]: "

#: fdisk/fdisk.c:1078
#, c-format
msgid "Using default value %d\n"
msgstr "Benutze den Standardwert %d\n"

#: fdisk/fdisk.c:1082
msgid "Value out of range.\n"
msgstr "Wert außerhalb des Bereichs.\n"

#: fdisk/fdisk.c:1092
msgid "Partition number"
msgstr "Partitionsnummer"

#: fdisk/fdisk.c:1101
#, c-format
msgid "Warning: partition %d has empty type\n"
msgstr ""

#: fdisk/fdisk.c:1108
msgid "cylinder"
msgstr "Zylinder"

#: fdisk/fdisk.c:1108
msgid "sector"
msgstr "Sektor"

#: fdisk/fdisk.c:1117
#, c-format
msgid "Changing display/entry units to %s\n"
msgstr "Die Einheit für die Anzeige/Eingabe ist nun %s\n"

#: fdisk/fdisk.c:1128
#, c-format
msgid "WARNING: Partition %d is an extended partition\n"
msgstr "WARNUNG: Partition %d ist eine erweiterte Partition\n"

#: fdisk/fdisk.c:1139
msgid "DOS Compatibility flag is set\n"
msgstr ""

#: fdisk/fdisk.c:1143
msgid "DOS Compatibility flag is not set\n"
msgstr ""

#: fdisk/fdisk.c:1229
#, c-format
msgid "Partition %d does not exist yet!\n"
msgstr "Partition %d existiert noch nicht!\n"

#: fdisk/fdisk.c:1234
msgid ""
"Type 0 means free space to many systems\n"
"(but not to Linux). Having partitions of\n"
"type 0 is probably unwise. You can delete\n"
"a partition using the `d' command.\n"
msgstr ""

#: fdisk/fdisk.c:1243
msgid ""
"You cannot change a partition into an extended one or vice versa\n"
"Delete it first.\n"
msgstr ""

#: fdisk/fdisk.c:1252
msgid ""
"Consider leaving partition 3 as Whole disk (5),\n"
"as SunOS/Solaris expects it and even Linux likes it.\n"
"\n"
msgstr ""

#: fdisk/fdisk.c:1258
msgid ""
"Consider leaving partition 9 as volume header (0),\n"
"and partition 11 as entire volume (6)as IRIX expects it.\n"
"\n"
msgstr ""

#: fdisk/fdisk.c:1272
#, c-format
msgid "Changed system type of partition %d to %x (%s)\n"
msgstr "Der Dateisystemtyp der Partition %d ist nun %x (%s)\n"

#: fdisk/fdisk.c:1326
#, c-format
msgid "Partition %d has different physical/logical beginnings (non-Linux?):\n"
msgstr ""

#: fdisk/fdisk.c:1328 fdisk/fdisk.c:1336 fdisk/fdisk.c:1345 fdisk/fdisk.c:1354
#, c-format
msgid "     phys=(%d, %d, %d) "
msgstr ""

#: fdisk/fdisk.c:1329 fdisk/fdisk.c:1337
#, c-format
msgid "logical=(%d, %d, %d)\n"
msgstr ""

#: fdisk/fdisk.c:1334
#, c-format
msgid "Partition %d has different physical/logical endings:\n"
msgstr ""

#: fdisk/fdisk.c:1343
#, c-format
msgid "Partition %i does not start on cylinder boundary:\n"
msgstr "Partition %i beginnt nicht an einer Zylindergrenze:\n"

#: fdisk/fdisk.c:1346
#, c-format
msgid "should be (%d, %d, 1)\n"
msgstr ""

#: fdisk/fdisk.c:1352
#, c-format
msgid "Partition %i does not end on cylinder boundary:\n"
msgstr "Partition %i endet nicht an einer Zylindergrenze:\n"

#: fdisk/fdisk.c:1355
#, c-format
msgid "should be (%d, %d, %d)\n"
msgstr ""

#: fdisk/fdisk.c:1362
#, c-format
msgid ""
"\n"
"Disk %s: %d heads, %d sectors, %d cylinders\n"
"Units = %s of %d * %d bytes\n"
"\n"
msgstr ""
"\n"
"Festplatte %s: %d Köpfe, %d Sektoren, %d Zylinder\n"
"Einheiten: %s mit %d * %d Bytes\n"
"\n"

#: fdisk/fdisk.c:1470
msgid ""
"Nothing to do. Ordering is correct already.\n"
"\n"
msgstr ""

#: fdisk/fdisk.c:1534
#, c-format
msgid "%*s Boot    Start       End    Blocks   Id  System\n"
msgstr "%*s boot.  Anfang      Ende    Blöcke   Id  Dateisystemtyp\n"

#: fdisk/fdisk.c:1535 fdisk/fdisksgilabel.c:221 fdisk/fdisksunlabel.c:676
msgid "Device"
msgstr "Gerät"

#: fdisk/fdisk.c:1572
msgid ""
"\n"
"Partition table entries are not in disk order\n"
msgstr ""

#: fdisk/fdisk.c:1582
#, c-format
msgid ""
"\n"
"Disk %s: %d heads, %d sectors, %d cylinders\n"
"\n"
msgstr ""
"\n"
"Festplatte %s: %d Köpfe, %d Sektoren, %d Zylinder\n"
"\n"

# Ist "Kp" eine gute Abkürzung für "Kopf" ?
#: fdisk/fdisk.c:1584
msgid "Nr AF  Hd Sec  Cyl  Hd Sec  Cyl    Start     Size ID\n"
msgstr "Nr AF  Kp Sek  Zyl  Kp Sek  Zyl   Anfang     Größe ID\n"

#: fdisk/fdisk.c:1628
#, c-format
msgid "Warning: partition %d contains sector 0\n"
msgstr "Warnung: Partition %d enthält Sektor 0\n"

#: fdisk/fdisk.c:1631
#, c-format
msgid "Partition %d: head %d greater than maximum %d\n"
msgstr ""

#: fdisk/fdisk.c:1634
#, c-format
msgid "Partition %d: sector %d greater than maximum %d\n"
msgstr ""

#: fdisk/fdisk.c:1637
#, c-format
msgid "Partitions %d: cylinder %d greater than maximum %d\n"
msgstr ""

#: fdisk/fdisk.c:1641
#, c-format
msgid "Partition %d: previous sectors %d disagrees with total %d\n"
msgstr ""

#: fdisk/fdisk.c:1673
#, c-format
msgid "Warning: bad start-of-data in partition %d\n"
msgstr ""

#: fdisk/fdisk.c:1681
#, c-format
msgid "Warning: partition %d overlaps partition %d.\n"
msgstr "Warnung: Partition %d überlappt mit Partition %d.\n"

#: fdisk/fdisk.c:1701
#, c-format
msgid "Warning: partition %d is empty\n"
msgstr "Warnung: Partition %d ist leer\n"

#: fdisk/fdisk.c:1706
#, c-format
msgid "Logical partition %d not entirely in partition %d\n"
msgstr ""
"Logische Partition %d ist nicht vollständig in Partition %d enthalten\n"

#: fdisk/fdisk.c:1712
#, c-format
msgid "Total allocated sectors %d greater than the maximum %d\n"
msgstr ""

#: fdisk/fdisk.c:1715
#, c-format
msgid "%d unallocated sectors\n"
msgstr "%d unbenutzte Sektoren\n"

#: fdisk/fdisk.c:1728 fdisk/fdisksgilabel.c:662 fdisk/fdisksunlabel.c:506
#, c-format
msgid "Partition %d is already defined.  Delete it before re-adding it.\n"
msgstr ""

# %s can be "Sektor" or "Zylinder".
#: fdisk/fdisk.c:1749 fdisk/fdiskbsdlabel.c:281 fdisk/fdisksgilabel.c:684
#: fdisk/fdisksunlabel.c:521
#, c-format
msgid "First %s"
msgstr "Erster %s"

#: fdisk/fdisk.c:1764 fdisk/fdisksunlabel.c:562
#, c-format
msgid "Sector %d is already allocated\n"
msgstr "Sektor %d wird bereits benutzt\n"

#: fdisk/fdisk.c:1800
msgid "No free sectors available\n"
msgstr "Es sind keine freien Sektoren verfügbar\n"

#: fdisk/fdisk.c:1809 fdisk/fdiskbsdlabel.c:288 fdisk/fdisksunlabel.c:573
#, c-format
msgid "Last %s or +size or +sizeM or +sizeK"
msgstr "Letzter %s oder +Größe, +GrößeK oder +GrößeM"

#: fdisk/fdisk.c:1874
msgid ""
"\tSorry - this fdisk cannot handle AIX disk labels.\n"
"\tIf you want to add DOS-type partitions, create\n"
"\ta new empty DOS partition table first. (Use o.)\n"
"\tWARNING: This will destroy the present disk contents.\n"
msgstr ""

#: fdisk/fdisk.c:1883 fdisk/fdiskbsdlabel.c:615
msgid "The maximum number of partitions has been created\n"
msgstr "Die maximale Anzahl von Partitionen wurde erzeugt\n"

#: fdisk/fdisk.c:1893
msgid "You must delete some partition and add an extended partition first\n"
msgstr ""

#: fdisk/fdisk.c:1898
#, c-format
msgid ""
"Command action\n"
"   %s\n"
"   p   primary partition (1-4)\n"
msgstr ""
"Befehl  Aktion\n"
"   %s\n"
"   p      Primäre Partition (1-4)\n"

#: fdisk/fdisk.c:1900
msgid "l   logical (5 or over)"
msgstr "l      Logische Partition (5 oder größer)"

#: fdisk/fdisk.c:1900
msgid "e   extended"
msgstr "e      Erweiterte"

#: fdisk/fdisk.c:1917
#, c-format
msgid "Invalid partition number for type `%c'\n"
msgstr "Ungültige Partitionsnummer für den Typ »%c«\n"

#: fdisk/fdisk.c:1952
msgid ""
"The partition table has been altered!\n"
"\n"
msgstr ""
"Die Partitionstabelle wurde verändert!\n"
"\n"

#: fdisk/fdisk.c:1961
msgid "Calling ioctl() to re-read partition table.\n"
msgstr ""

#: fdisk/fdisk.c:1977
#, c-format
msgid ""
"\n"
"WARNING: Re-reading the partition table failed with error %d: %s.\n"
"The kernel still uses the old table.\n"
"The new table will be used at the next reboot.\n"
msgstr ""

#: fdisk/fdisk.c:1987
msgid ""
"\n"
"WARNING: If you have created or modified any DOS 6.x\n"
"partitions, please see the fdisk manual page for additional\n"
"information.\n"
msgstr ""
"\n"
"WARNUNG: Wenn Sie eine DOS 6.x Partition angelegt\n"
"oder verändert haben, dann schauen Sie bitte in die\n"
"fdisk-manual-Seite nach weiteren Informationen\n"

#: fdisk/fdisk.c:1994
msgid "Syncing disks.\n"
msgstr ""

#: fdisk/fdisk.c:2041
#, c-format
msgid "Partition %d has no data area\n"
msgstr "Partition %d hat keinen Datenbereich\n"

#: fdisk/fdisk.c:2046
msgid "New beginning of data"
msgstr ""

# That sounds pretty ummm...
#: fdisk/fdisk.c:2062
msgid "Expert command (m for help): "
msgstr "Expertenkommando (m für Hilfe): "

#: fdisk/fdisk.c:2075
msgid "Number of cylinders"
msgstr "Anzahl der Zylinder"

#: fdisk/fdisk.c:2101
msgid "Number of heads"
msgstr "Anzahl der Köpfe"

#: fdisk/fdisk.c:2126
msgid "Number of sectors"
msgstr "Anzahl der Sektoren"

#: fdisk/fdisk.c:2129
msgid "Warning: setting sector offset for DOS compatiblity\n"
msgstr ""

#: fdisk/fdisk.c:2204
#, c-format
msgid "Disk %s doesn't contain a valid partition table\n"
msgstr "Festplatte %s enthält keine gültige Partitionstabelle\n"

#: fdisk/fdisk.c:2218
#, c-format
msgid "Cannot open %s\n"
msgstr "Konnte %s nicht öffnen\n"

#: fdisk/fdisk.c:2234
#, c-format
msgid "cannot open %s\n"
msgstr "Konnte %s nicht öffnen\n"

#: fdisk/fdisk.c:2256
#, c-format
msgid "%c: unknown command\n"
msgstr "%c: Unbekannter Befehl\n"

#: fdisk/fdisk.c:2306
msgid "This kernel finds the sector size itself - -b option ignored\n"
msgstr ""

#: fdisk/fdisk.c:2309
msgid ""
"Warning: the -b (set sector size) option should be used with one specified "
"device\n"
msgstr ""

#: fdisk/fdisk.c:2372
#, c-format
msgid ""
"Detected an OSF/1 disklabel on %s, entering disklabel mode.\n"
"To return to DOS partition table mode, use the 'r' command.\n"
msgstr ""

#: fdisk/fdisk.c:2381
msgid "Command (m for help): "
msgstr "Befehl (m für Hilfe): "

#: fdisk/fdisk.c:2397
#, c-format
msgid ""
"\n"
"The current boot file is: %s\n"
msgstr ""

#: fdisk/fdisk.c:2399
msgid "Please enter the name of the new boot file: "
msgstr ""

#: fdisk/fdisk.c:2401
msgid "Boot file unchanged\n"
msgstr ""

#: fdisk/fdisk.c:2465
msgid ""
"\n"
"\tSorry, no experts menu for SGI partition tables available.\n"
"\n"
msgstr ""

#: fdisk/fdiskaixlabel.c:28
msgid ""
"\n"
"\tThere is a valid AIX label on this disk.\n"
"\tUnfortunately Linux cannot handle these\n"
"\tdisks at the moment.  Nevertheless some\n"
"\tadvice:\n"
"\t1. fdisk will destroy its contents on write.\n"
"\t2. Be sure that this disk is NOT a still vital\n"
"\t   part of a volume group. (Otherwise you may\n"
"\t   erase the other disks as well, if unmirrored.)\n"
"\t3. Before deleting this physical volume be sure\n"
"\t   to remove the disk logically from your AIX\n"
"\t   machine.  (Otherwise you become an AIXpert)."
msgstr ""

#: fdisk/fdiskbsdlabel.c:119
#, c-format
msgid ""
"\n"
"BSD label for device: %s\n"
msgstr ""
"\n"
"»BSD label« von %s\n"

#: fdisk/fdiskbsdlabel.c:127
msgid "   d   delete a BSD partition"
msgstr "   d   Eine BSD-Partition löschen"

#: fdisk/fdiskbsdlabel.c:128
msgid "   e   edit drive data"
msgstr ""

#: fdisk/fdiskbsdlabel.c:129
msgid "   i   install bootstrap"
msgstr ""

#: fdisk/fdiskbsdlabel.c:130
msgid "   l   list known filesystem types"
msgstr "   l   Die bekannten Dateisystemtypen anzeigen"

#: fdisk/fdiskbsdlabel.c:132
msgid "   n   add a new BSD partition"
msgstr "   n   Eine neue BSD-Partition anlegen"

#: fdisk/fdiskbsdlabel.c:133
msgid "   p   print BSD partition table"
msgstr "   p   Die BSD-Partitionstabelle anzeigen"

#: fdisk/fdiskbsdlabel.c:136
msgid "   s   show complete disklabel"
msgstr ""

#: fdisk/fdiskbsdlabel.c:137
msgid "   t   change a partition's filesystem id"
msgstr "   t   Den Dateisystemtyp einer Partition ändern"

#: fdisk/fdiskbsdlabel.c:138
msgid "   u   change units (cylinders/sectors)"
msgstr ""

#: fdisk/fdiskbsdlabel.c:139
msgid "   w   write disklabel to disk"
msgstr ""

#: fdisk/fdiskbsdlabel.c:141
msgid "   x   link BSD partition to non-BSD partition"
msgstr ""

#: fdisk/fdiskbsdlabel.c:173
#, fuzzy, c-format
msgid "Partition %s has invalid starting sector 0.\n"
msgstr "Warnung: Partition %d fängt bei Sektor 0 an\n"

#: fdisk/fdiskbsdlabel.c:177
#, c-format
msgid "Reading disklabel of %s at sector %d.\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:187
#, c-format
msgid "There is no *BSD partition on %s.\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:201
msgid "BSD disklabel command (m for help): "
msgstr "»BSD disklabel« Befehl (m für Hilfe): "

#: fdisk/fdiskbsdlabel.c:315
#, c-format
msgid "type: %s\n"
msgstr "Typ: %s\n"

#: fdisk/fdiskbsdlabel.c:317
#, c-format
msgid "type: %d\n"
msgstr "Typ: %d\n"

#: fdisk/fdiskbsdlabel.c:318
#, c-format
msgid "disk: %.*s\n"
msgstr "Festplatte: %.*s\n"

#: fdisk/fdiskbsdlabel.c:319
#, c-format
msgid "label: %.*s\n"
msgstr ""

# I currently don't know a better translation
#: fdisk/fdiskbsdlabel.c:320
msgid "flags:"
msgstr "Flags:"

#: fdisk/fdiskbsdlabel.c:322
msgid " removable"
msgstr ""

#: fdisk/fdiskbsdlabel.c:324
msgid " ecc"
msgstr ""

#: fdisk/fdiskbsdlabel.c:326
msgid " badsect"
msgstr ""

#. On various machines the fields of *lp are short/int/long
#. In order to avoid problems, we cast them all to long.
#: fdisk/fdiskbsdlabel.c:330
#, c-format
msgid "bytes/sector: %ld\n"
msgstr "Bytes/Sektor: %ld\n"

#: fdisk/fdiskbsdlabel.c:331
#, c-format
msgid "sectors/track: %ld\n"
msgstr "Sektoren/Spur: %ld\n"

#: fdisk/fdiskbsdlabel.c:332
#, c-format
msgid "tracks/cylinder: %ld\n"
msgstr "Spuren/Zylinder: %ld\n"

#: fdisk/fdiskbsdlabel.c:333
#, c-format
msgid "sectors/cylinder: %ld\n"
msgstr "Sektoren/Zylinder: %ld\n"

#: fdisk/fdiskbsdlabel.c:334
#, c-format
msgid "cylinders: %ld\n"
msgstr "Zylinder: %ld\n"

#: fdisk/fdiskbsdlabel.c:335
#, c-format
msgid "rpm: %d\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:336
#, c-format
msgid "interleave: %d\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:337
#, c-format
msgid "trackskew: %d\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:338
#, c-format
msgid "cylinderskew: %d\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:339
#, c-format
msgid "headswitch: %ld\t\t# milliseconds\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:341
#, c-format
msgid "track-to-track seek: %ld\t# milliseconds\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:343
msgid "drivedata: "
msgstr ""

#: fdisk/fdiskbsdlabel.c:352
#, c-format
msgid ""
"\n"
"%d partitions:\n"
msgstr ""
"\n"
"%d Partitionen:\n"

#: fdisk/fdiskbsdlabel.c:353
msgid "#       start       end      size     fstype   [fsize bsize   cpg]\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:402 fdisk/fdiskbsdlabel.c:405
#, c-format
msgid "Writing disklabel to %s.\n"
msgstr "Schreibe »disklabel« auf %s.\n"

#: fdisk/fdiskbsdlabel.c:417 fdisk/fdiskbsdlabel.c:419
#, c-format
msgid "%s contains no disklabel.\n"
msgstr "%s enthält keinen »disklabel«.\n"

#: fdisk/fdiskbsdlabel.c:424
msgid "Do you want to create a disklabel? (y/n) "
msgstr "Wollen Sie einen »disklabel« anlegen (y/n)? "

#: fdisk/fdiskbsdlabel.c:463
msgid "bytes/sector"
msgstr "Bytes/Sektor"

#: fdisk/fdiskbsdlabel.c:464
msgid "sectors/track"
msgstr "Sektoren/Spur"

#: fdisk/fdiskbsdlabel.c:465
msgid "tracks/cylinder"
msgstr "Spuren/Zylinder"

#: fdisk/fdiskbsdlabel.c:473
msgid "sectors/cylinder"
msgstr "Sektoren/Zylinder"

#: fdisk/fdiskbsdlabel.c:477
msgid "Must be <= sectors/track * tracks/cylinder (default).\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:479
msgid "rpm"
msgstr ""

#: fdisk/fdiskbsdlabel.c:480
msgid "interleave"
msgstr ""

#: fdisk/fdiskbsdlabel.c:481
msgid "trackskew"
msgstr ""

#: fdisk/fdiskbsdlabel.c:482
msgid "cylinderskew"
msgstr ""

#: fdisk/fdiskbsdlabel.c:483
msgid "headswitch"
msgstr ""

#: fdisk/fdiskbsdlabel.c:484
msgid "track-to-track seek"
msgstr ""

#: fdisk/fdiskbsdlabel.c:525
#, c-format
msgid "Bootstrap: %sboot -> boot%s (%s): "
msgstr ""

#: fdisk/fdiskbsdlabel.c:550
msgid "Bootstrap overlaps with disk label!\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:571 fdisk/fdiskbsdlabel.c:573
#, c-format
msgid "Bootstrap installed on %s.\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:595
#, c-format
msgid "Partition (a-%c): "
msgstr "Partition (a-%c): "

#: fdisk/fdiskbsdlabel.c:626
msgid "This partition already exists.\n"
msgstr "Diese Partition existiert bereits.\n"

#: fdisk/fdiskbsdlabel.c:746
#, c-format
msgid "Warning: too many partitions (%d, maximum is %d).\n"
msgstr ""

#: fdisk/fdiskbsdlabel.c:793
msgid ""
"\n"
"Syncing disks.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:79
msgid "SGI volhdr"
msgstr "SGI volhdr"

#: fdisk/fdisksgilabel.c:80
msgid "SGI trkrepl"
msgstr "SGI trkrepl"

#: fdisk/fdisksgilabel.c:81
msgid "SGI secrepl"
msgstr "SGI secrepl"

#: fdisk/fdisksgilabel.c:82
msgid "SGI raw"
msgstr "SGI raw"

#: fdisk/fdisksgilabel.c:83
msgid "SGI bsd"
msgstr "SGI bsd"

#: fdisk/fdisksgilabel.c:84
msgid "SGI sysv"
msgstr "SGI sysv"

#: fdisk/fdisksgilabel.c:85
msgid "SGI volume"
msgstr "SGI volume"

#: fdisk/fdisksgilabel.c:86
msgid "SGI efs"
msgstr "SGI efs"

#: fdisk/fdisksgilabel.c:87
msgid "SGI lvol"
msgstr "SGI lvol"

#: fdisk/fdisksgilabel.c:88
msgid "SGI rlvol"
msgstr "SGI rlvol"

#: fdisk/fdisksgilabel.c:89
msgid "SGI xfs"
msgstr "SGI xfs"

#: fdisk/fdisksgilabel.c:90
msgid "SGI xfslog"
msgstr "SGI xfslog"

#: fdisk/fdisksgilabel.c:91
msgid "SGI xlv"
msgstr "SGI xlv"

#: fdisk/fdisksgilabel.c:92
msgid "SGI xvm"
msgstr "SGI xvm"

#. Minix 1.4b and later
#: fdisk/fdisksgilabel.c:93 fdisk/fdisksunlabel.c:52 fdisk/i386_sys_types.c:56
msgid "Linux swap"
msgstr "Linux Swap"

#: fdisk/fdisksgilabel.c:94 fdisk/fdisksunlabel.c:53
msgid "Linux native"
msgstr "Linux native"

#: fdisk/fdisksgilabel.c:95 fdisk/fdisksunlabel.c:54 fdisk/i386_sys_types.c:62
msgid "Linux LVM"
msgstr "Linux LVM"

#: fdisk/fdisksgilabel.c:96
#, fuzzy
msgid "Linux RAID"
msgstr "Linux"

#: fdisk/fdisksgilabel.c:159
msgid ""
"According to MIPS Computer Systems, Inc the Label must not contain more than "
"512 bytes\n"
msgstr ""

#: fdisk/fdisksgilabel.c:178
msgid "Detected sgi disklabel with wrong checksum.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:201
#, c-format
msgid ""
"\n"
"Disk %s (SGI disk label): %d heads, %d sectors\n"
"%d cylinders, %d physical cylinders\n"
"%d extra sects/cyl, interleave %d:1\n"
"%s\n"
"Units = %s of %d * 512 bytes\n"
"\n"
msgstr ""

#: fdisk/fdisksgilabel.c:213
#, c-format
msgid ""
"\n"
"Disk %s (SGI disk label): %d heads, %d sectors, %d cylinders\n"
"Units = %s of %d * 512 bytes\n"
"\n"
msgstr ""
"\n"
"Festplatte %s (»SGI disklabel«): %d Köpfe, %d Sektoren, %d Zylinder\n"
"Einheiten: %s mit %d * 512 Bytes\n"
"\n"

#: fdisk/fdisksgilabel.c:219
#, fuzzy, c-format
msgid ""
"----- partitions -----\n"
"Pt# %*s  Info     Start       End   Sectors  Id  System\n"
msgstr "%*s boot.  Anfang      Ende    Blöcke   Id  Dateisystemtyp\n"

#: fdisk/fdisksgilabel.c:241
#, c-format
msgid ""
"----- Bootinfo -----\n"
"Bootfile: %s\n"
"----- Directory Entries -----\n"
msgstr ""

#: fdisk/fdisksgilabel.c:251
#, c-format
msgid "%2d: %-10s sector%5u size%8u\n"
msgstr ""

#: fdisk/fdisksgilabel.c:305
msgid ""
"\n"
"Invalid Bootfile!\n"
"\tThe bootfile must be an absolute non-zero pathname,\n"
"\te.g. \"/unix\" or \"/unix.save\".\n"
msgstr ""

#: fdisk/fdisksgilabel.c:312
msgid ""
"\n"
"\tName of Bootfile too long:  16 bytes maximum.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:317
msgid ""
"\n"
"\tBootfile must have a fully qualified pathname.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:322
msgid ""
"\n"
"\tBe aware, that the bootfile is not checked for existence.\n"
"\tSGI's default is \"/unix\" and for backup \"/unix.save\".\n"
msgstr ""

#: fdisk/fdisksgilabel.c:350
#, c-format
msgid ""
"\n"
"\tBootfile is changed to \"%s\".\n"
msgstr ""

#: fdisk/fdisksgilabel.c:448
msgid "More than one entire disk entry present.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:456 fdisk/fdisksunlabel.c:482
msgid "No partitions defined\n"
msgstr ""

#: fdisk/fdisksgilabel.c:463
msgid "IRIX likes when Partition 11 covers the entire disk.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:465
#, c-format
msgid ""
"The entire disk partition should start at block 0,\n"
"not at diskblock %d.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:469
#, c-format
msgid ""
"The entire disk partition is only %d diskblock large,\n"
"but the disk is %d diskblocks long.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:476
msgid "One Partition (#11) should cover the entire disk.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:488
#, c-format
msgid "Partition %d does not start on cylinder boundary.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:495
#, c-format
msgid "Partition %d does not end on cylinder boundary.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:503
#, c-format
msgid "The Partition %d and %d overlap by %d sectors.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:512 fdisk/fdisksgilabel.c:532
#, c-format
msgid "Unused gap of %8d sectors - sectors %8d-%d\n"
msgstr ""

#: fdisk/fdisksgilabel.c:545
msgid ""
"\n"
"The boot partition does not exist.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:549
msgid ""
"\n"
"The swap partition does not exist.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:554
msgid ""
"\n"
"The swap partition has no swap type.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:558
msgid "\tYou have chosen an unusual boot file name.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:569
msgid "Sorry You may change the Tag of non-empty partitions.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:576
msgid ""
"It is highly recommended that the partition at offset 0\n"
"is of type \"SGI volhdr\", the IRIX system will rely on it to\n"
"retrieve from its directory standalone tools like sash and fx.\n"
"Only the \"SGI volume\" entire disk section may violate this.\n"
"Type YES if you are sure about tagging this partition differently.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:581 fdisk/fdisksunlabel.c:630
msgid "YES\n"
msgstr ""

#. rebuild freelist
#: fdisk/fdisksgilabel.c:607
msgid "Do You know, You got a partition overlap on the disk?\n"
msgstr ""

#: fdisk/fdisksgilabel.c:669
msgid "Attempting to generate entire disk entry automatically.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:676
msgid "The entire disk is already covered with partitions.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:681
msgid "You got a partition overlap on the disk. Fix it first!\n"
msgstr ""

#: fdisk/fdisksgilabel.c:690 fdisk/fdisksgilabel.c:719
msgid ""
"It is highly recommended that eleventh partition\n"
"covers the entire disk and is of type `SGI volume'\n"
msgstr ""

#: fdisk/fdisksgilabel.c:706
msgid "You will get a partition overlap on the disk. Fix it first!\n"
msgstr ""

#: fdisk/fdisksgilabel.c:711
#, c-format
msgid " Last %s"
msgstr ""

#: fdisk/fdisksgilabel.c:733
msgid ""
"Building a new SGI disklabel. Changes will remain in memory only,\n"
"until you decide to write them. After that, of course, the previous\n"
"content will be unrecoverably lost.\n"
"\n"
msgstr ""

#: fdisk/fdisksgilabel.c:759
#, c-format
msgid "Trying to keep parameters of partition %d.\n"
msgstr ""

#: fdisk/fdisksgilabel.c:761
#, c-format
msgid "ID=%02x\tSTART=%d\tLENGTH=%d\n"
msgstr ""

#: fdisk/fdisksunlabel.c:43 fdisk/i386_sys_types.c:6
msgid "Empty"
msgstr "Leer"

#: fdisk/fdisksunlabel.c:45
msgid "SunOS root"
msgstr "SunOS root"

#: fdisk/fdisksunlabel.c:46
msgid "SunOS swap"
msgstr "SunOS Swap"

#: fdisk/fdisksunlabel.c:47
msgid "SunOS usr"
msgstr "SunOS usr"

#: fdisk/fdisksunlabel.c:48
msgid "Whole disk"
msgstr ""

#: fdisk/fdisksunlabel.c:49
msgid "SunOS stand"
msgstr "SunOS stand"

#: fdisk/fdisksunlabel.c:50
msgid "SunOS var"
msgstr "SunOS var"

#: fdisk/fdisksunlabel.c:51
msgid "SunOS home"
msgstr "SunOS home"

#. DOS 3.3+ secondary
#: fdisk/fdisksunlabel.c:55 fdisk/i386_sys_types.c:95
msgid "Linux raid autodetect"
msgstr "Linux raid autodetect"

#: fdisk/fdisksunlabel.c:132
msgid ""
"Detected sun disklabel with wrong checksum.\n"
"Probably you'll have to set all the values,\n"
"e.g. heads, sectors, cylinders and partitions\n"
"or force a fresh label (s command in main menu)\n"
msgstr ""

#: fdisk/fdisksunlabel.c:231
#, c-format
msgid "Autoconfigure found a %s%s%s\n"
msgstr ""

#: fdisk/fdisksunlabel.c:258
msgid ""
"Building a new sun disklabel. Changes will remain in memory only,\n"
"until you decide to write them. After that, of course, the previous\n"
"content won't be recoverable.\n"
"\n"
msgstr ""

#: fdisk/fdisksunlabel.c:269
msgid ""
"Drive type\n"
"   ?   auto configure\n"
"   0   custom (with hardware detected defaults)"
msgstr ""

#: fdisk/fdisksunlabel.c:279
msgid "Select type (? for auto, 0 for custom): "
msgstr ""

#: fdisk/fdisksunlabel.c:291
msgid "Autoconfigure failed.\n"
msgstr ""

#: fdisk/fdisksunlabel.c:319
msgid "Sectors/track"
msgstr "Sektoren/Spur"

#: fdisk/fdisksunlabel.c:326
msgid "Alternate cylinders"
msgstr ""

#: fdisk/fdisksunlabel.c:329
msgid "Physical cylinders"
msgstr ""

#: fdisk/fdisksunlabel.c:332 fdisk/fdisksunlabel.c:726
msgid "Rotation speed (rpm)"
msgstr ""

#: fdisk/fdisksunlabel.c:334 fdisk/fdisksunlabel.c:719
msgid "Interleave factor"
msgstr ""

#: fdisk/fdisksunlabel.c:337 fdisk/fdisksunlabel.c:712
msgid "Extra sectors per cylinder"
msgstr ""

#: fdisk/fdisksunlabel.c:351
msgid "You may change all the disk params from the x menu"
msgstr ""

#: fdisk/fdisksunlabel.c:358
msgid "3,5\" floppy"
msgstr ""

#: fdisk/fdisksunlabel.c:358
msgid "Linux custom"
msgstr "Linux custom"

#: fdisk/fdisksunlabel.c:445
#, c-format
msgid "Partition %d doesn't end on cylinder boundary\n"
msgstr "Partition %d endet nicht an einer Zylindergrenze\n"

#: fdisk/fdisksunlabel.c:465
#, c-format
msgid "Partition %d overlaps with others in sectors %d-%d\n"
msgstr ""

#: fdisk/fdisksunlabel.c:487
#, c-format
msgid "Unused gap - sectors 0-%d\n"
msgstr "Unbenutzter Bereich - Sektor 0-%d\n"

#: fdisk/fdisksunlabel.c:489 fdisk/fdisksunlabel.c:493
#, c-format
msgid "Unused gap - sectors %d-%d\n"
msgstr "Unbenutzter Bereich - Sektor %d-%d\n"

#: fdisk/fdisksunlabel.c:516
msgid ""
"Other partitions already cover the whole disk.\n"
"Delete some/shrink them before retry.\n"
msgstr ""

#: fdisk/fdisksunlabel.c:592
#, c-format
msgid ""
"You haven't covered the whole disk with the 3rd partition, but your value\n"
"%d %s covers some other partition. Your entry has been changed\n"
"to %d %s\n"
msgstr ""

#: fdisk/fdisksunlabel.c:612
#, c-format
msgid ""
"If you want to maintain SunOS/Solaris compatibility, consider leaving this\n"
"partition as Whole disk (5), starting at 0, with %u sectors\n"
msgstr ""

#: fdisk/fdisksunlabel.c:625
msgid ""
"It is highly recommended that the partition at offset 0\n"
"is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n"
"there may destroy your partition table and bootblock.\n"
"Type YES if you're very sure you would like that partition\n"
"tagged with 82 (Linux swap): "
msgstr ""

#: fdisk/fdisksunlabel.c:656
#, c-format
msgid ""
"\n"
"Disk %s (Sun disk label): %d heads, %d sectors, %d rpm\n"
"%d cylinders, %d alternate cylinders, %d physical cylinders\n"
"%d extra sects/cyl, interleave %d:1\n"
"%s\n"
"Units = %s of %d * 512 bytes\n"
"\n"
msgstr ""

#: fdisk/fdisksunlabel.c:670
#, fuzzy, c-format
msgid ""
"\n"
"Disk %s (Sun disk label): %d heads, %d sectors, %d cylinders\n"
"Units = %s of %d * 512 bytes\n"
"\n"
msgstr ""
"\n"
"Festplatte %s (»Sun disklabel«): %d Köpfe, %d Sektoren, %d Zylinder\n"
"Einheiten: %s mit %d * 512 Bytes\n"
"\n"

#: fdisk/fdisksunlabel.c:675
#, c-format
msgid "%*s Flag    Start       End    Blocks   Id  System\n"
msgstr ""

#: fdisk/fdisksunlabel.c:700
msgid "Number of alternate cylinders"
msgstr ""

#: fdisk/fdisksunlabel.c:733
msgid "Number of physical cylinders"
msgstr ""

#: fdisk/i386_sys_types.c:7
msgid "FAT12"
msgstr "FAT12"

#: fdisk/i386_sys_types.c:8
msgid "XENIX root"
msgstr "XENIX root"

#: fdisk/i386_sys_types.c:9
msgid "XENIX usr"
msgstr "XENIX usr"

#: fdisk/i386_sys_types.c:10
msgid "FAT16 <32M"
msgstr "FAT16 <32M"

#: fdisk/i386_sys_types.c:11
msgid "Extended"
msgstr "Erweiterte"

#. DOS 3.3+ extended partition
#: fdisk/i386_sys_types.c:12
msgid "FAT16"
msgstr "FAT16"

#. DOS 16-bit >=32M
#: fdisk/i386_sys_types.c:13
msgid "HPFS/NTFS"
msgstr "HPFS/NTFS"

#. OS/2 IFS, eg, HPFS or NTFS or QNX
#: fdisk/i386_sys_types.c:14
msgid "AIX"
msgstr "AIX"

# "bootfähig"
#. AIX boot (AIX -- PS/2 port) or SplitDrive
#: fdisk/i386_sys_types.c:15
msgid "AIX bootable"
msgstr "AIX bootfähig"

#. AIX data or Coherent
#: fdisk/i386_sys_types.c:16
msgid "OS/2 Boot Manager"
msgstr "OS/2 Bootmanager"

#. OS/2 Boot Manager
#: fdisk/i386_sys_types.c:17
msgid "Win95 FAT32"
msgstr "Win95 FAT32"

#: fdisk/i386_sys_types.c:18
msgid "Win95 FAT32 (LBA)"
msgstr "Win95 FAT32 (LBA)"

#. LBA really is `Extended Int 13h'
#: fdisk/i386_sys_types.c:19
msgid "Win95 FAT16 (LBA)"
msgstr "Win95 FAT16 (LBA)"

#: fdisk/i386_sys_types.c:20
msgid "Win95 Ext'd (LBA)"
msgstr "Win95 Erw. (LBA)"

#: fdisk/i386_sys_types.c:21
msgid "OPUS"
msgstr "OPUS"

#: fdisk/i386_sys_types.c:22
msgid "Hidden FAT12"
msgstr "Verst. FAT12"

#: fdisk/i386_sys_types.c:23
msgid "Compaq diagnostics"
msgstr "Compaq Diagnostics"

#: fdisk/i386_sys_types.c:24
msgid "Hidden FAT16 <32M"
msgstr "Verst. FAT16 <32M"

#: fdisk/i386_sys_types.c:25
msgid "Hidden FAT16"
msgstr "Verst. FAT16"

#: fdisk/i386_sys_types.c:26
msgid "Hidden HPFS/NTFS"
msgstr "Verst. HPFS/NTFS"

#: fdisk/i386_sys_types.c:27
msgid "AST SmartSleep"
msgstr ""

#: fdisk/i386_sys_types.c:28
msgid "Hidden Win95 FAT32"
msgstr "Verst. Win95 FAT32"

#: fdisk/i386_sys_types.c:29
msgid "Hidden Win95 FAT32 (LBA)"
msgstr "Verst. Win95 FAT32 (LBA)"

#: fdisk/i386_sys_types.c:30
msgid "Hidden Win95 FAT16 (LBA)"
msgstr "Verst. Win95 FAT16 (LBA)"

#: fdisk/i386_sys_types.c:31
msgid "NEC DOS"
msgstr "NEC DOS"

#: fdisk/i386_sys_types.c:32
msgid "Plan 9"
msgstr "Plan 9"

#: fdisk/i386_sys_types.c:33
msgid "PartitionMagic recovery"
msgstr "PartitionMagic recovery"

#: fdisk/i386_sys_types.c:34
msgid "Venix 80286"
msgstr "Venix 80286"

#: fdisk/i386_sys_types.c:35
msgid "PPC PReP Boot"
msgstr "PPC PReP Boot"

#: fdisk/i386_sys_types.c:36
msgid "SFS"
msgstr "SFS"

#: fdisk/i386_sys_types.c:37
msgid "QNX4.x"
msgstr "QNX4.x"

#: fdisk/i386_sys_types.c:38
msgid "QNX4.x 2nd part"
msgstr "QNX4.x 2nd part"

#: fdisk/i386_sys_types.c:39
msgid "QNX4.x 3rd part"
msgstr "QNX4.x 3rd part"

#: fdisk/i386_sys_types.c:40
msgid "OnTrack DM"
msgstr "OnTrack DM"

#: fdisk/i386_sys_types.c:41
msgid "OnTrack DM6 Aux1"
msgstr "OnTrack DM6 Aux1"

#. (or Novell)
#: fdisk/i386_sys_types.c:42
msgid "CP/M"
msgstr "CP/M"

#. CP/M or Microport SysV/AT
#: fdisk/i386_sys_types.c:43
msgid "OnTrack DM6 Aux3"
msgstr "OnTrack DM6 Aux3"

#: fdisk/i386_sys_types.c:44
msgid "OnTrackDM6"
msgstr "OnTrackDM6"

#: fdisk/i386_sys_types.c:45
msgid "EZ-Drive"
msgstr "EZ-Drive"

#: fdisk/i386_sys_types.c:46
msgid "Golden Bow"
msgstr "Golden Bow"

#: fdisk/i386_sys_types.c:47
msgid "Priam Edisk"
msgstr "Priam Edisk"

#. DOS R/O or SpeedStor
#: fdisk/i386_sys_types.c:48 fdisk/i386_sys_types.c:86
#: fdisk/i386_sys_types.c:92 fdisk/i386_sys_types.c:93
msgid "SpeedStor"
msgstr "SpeedStor"

#: fdisk/i386_sys_types.c:49
msgid "GNU HURD or SysV"
msgstr "GNU HURD / SysV"

#. GNU HURD or Mach or Sys V/386 (such as ISC UNIX)
#: fdisk/i386_sys_types.c:50
msgid "Novell Netware 286"
msgstr "Novell Netware 286"

#: fdisk/i386_sys_types.c:51
msgid "Novell Netware 386"
msgstr "Novell Netware 386"

#: fdisk/i386_sys_types.c:52
msgid "DiskSecure Multi-Boot"
msgstr "DiskSecure Multi-Boot"

#: fdisk/i386_sys_types.c:53
msgid "PC/IX"
msgstr "PC/IX"

#: fdisk/i386_sys_types.c:54
msgid "Old Minix"
msgstr "Old Minix"

#. Minix 1.4a and earlier
#: fdisk/i386_sys_types.c:55
msgid "Minix / old Linux"
msgstr "Minix / old Linux"

#: fdisk/i386_sys_types.c:58
msgid "OS/2 hidden C: drive"
msgstr "OS/2 verst. C:-Lw."

#: fdisk/i386_sys_types.c:59
msgid "Linux extended"
msgstr "Linux erweitert"

#: fdisk/i386_sys_types.c:60 fdisk/i386_sys_types.c:61
msgid "NTFS volume set"
msgstr "NTFS volume set"

#: fdisk/i386_sys_types.c:63
msgid "Amoeba"
msgstr "Amoeba"

#: fdisk/i386_sys_types.c:64
msgid "Amoeba BBT"
msgstr "Amoeba BBT"

#. (bad block table)
#: fdisk/i386_sys_types.c:65
msgid "BSD/OS"
msgstr "BSD/OS"

#. BSDI
#: fdisk/i386_sys_types.c:66
msgid "IBM Thinkpad hibernation"
msgstr "IBM Thinkpad hibernation"

#: fdisk/i386_sys_types.c:67
msgid "FreeBSD"
msgstr ""

#. various BSD flavours
#: fdisk/i386_sys_types.c:68
msgid "OpenBSD"
msgstr "OpenBSD"

#: fdisk/i386_sys_types.c:69
msgid "NeXTSTEP"
msgstr "NeXTSTEP"

#: fdisk/i386_sys_types.c:70
#, fuzzy
msgid "NetBSD"
msgstr "OpenBSD"

#: fdisk/i386_sys_types.c:71
msgid "BSDI fs"
msgstr "BSDI fs"

#: fdisk/i386_sys_types.c:72
msgid "BSDI swap"
msgstr "BSDI swap"

#: fdisk/i386_sys_types.c:73
msgid "Boot Wizard hidden"
msgstr ""

#: fdisk/i386_sys_types.c:74
msgid "DRDOS/sec (FAT-12)"
msgstr "DRDOS/sec (FAT-12)"

#: fdisk/i386_sys_types.c:75
msgid "DRDOS/sec (FAT-16 < 32M)"
msgstr "DRDOS/sec (FAT-16 < 32M)"

#: fdisk/i386_sys_types.c:76
msgid "DRDOS/sec (FAT-16)"
msgstr "DRDOS/sec (FAT-16)"

#: fdisk/i386_sys_types.c:77
msgid "Syrinx"
msgstr "Syrinx"

#: fdisk/i386_sys_types.c:78
msgid "Non-FS data"
msgstr ""

#: fdisk/i386_sys_types.c:79
msgid "CP/M / CTOS / ..."
msgstr "CP/M / CTOS / ..."

#. CP/M or Concurrent CP/M or
#. Concurrent DOS or CTOS
#: fdisk/i386_sys_types.c:81
msgid "Dell Utility"
msgstr ""

#. Dell PowerEdge Server utilities
#: fdisk/i386_sys_types.c:82
#, fuzzy
msgid "BootIt"
msgstr "Boot"

#. BootIt EMBRM
#: fdisk/i386_sys_types.c:83
msgid "DOS access"
msgstr "DOS access"

#. DOS access or SpeedStor 12-bit FAT
#. extended partition
#: fdisk/i386_sys_types.c:85
msgid "DOS R/O"
msgstr "DOS R/O"

#. SpeedStor 16-bit FAT extended
#. partition < 1024 cyl.
#: fdisk/i386_sys_types.c:88
msgid "BeOS fs"
msgstr "BeOS fs"

#: fdisk/i386_sys_types.c:89
msgid "EFI GPT"
msgstr ""

#. Intel EFI GUID Partition Table
#: fdisk/i386_sys_types.c:90
msgid "EFI (FAT-12/16/32)"
msgstr ""

#. Intel EFI System Partition
#: fdisk/i386_sys_types.c:91
msgid "Linux/PA-RISC boot"
msgstr ""

#. SpeedStor large partition
#: fdisk/i386_sys_types.c:94
msgid "DOS secondary"
msgstr "DOS secondary"

#. New (2.2.x) raid partition with
#. autodetect using persistent
#. superblock
#: fdisk/i386_sys_types.c:98
msgid "LANstep"
msgstr "LANstep"

#. SpeedStor >1024 cyl. or LANstep
#: fdisk/i386_sys_types.c:99
msgid "BBT"
msgstr "BBT"

#: fdisk/sfdisk.c:152
#, c-format
msgid "seek error on %s - cannot seek to %lu\n"
msgstr ""

#: fdisk/sfdisk.c:157
#, c-format
msgid "seek error: wanted 0x%08x%08x, got 0x%08x%08x\n"
msgstr ""

#: fdisk/sfdisk.c:203
msgid "out of memory - giving up\n"
msgstr ""

#: fdisk/sfdisk.c:208 fdisk/sfdisk.c:291
#, fuzzy, c-format
msgid "read error on %s - cannot read sector %lu\n"
msgstr ""
"Fehler beim Lesen von %s - der Sektor %lu konnte nicht gelesen werden\n"

#: fdisk/sfdisk.c:226
#, c-format
msgid "ERROR: sector %lu does not have an msdos signature\n"
msgstr ""

#: fdisk/sfdisk.c:241
#, fuzzy, c-format
msgid "write error on %s - cannot write sector %lu\n"
msgstr ""
"Fehler beim Schreiben auf %s - der Sektor %lu konnte nicht geschrieben "
"werden\n"

#: fdisk/sfdisk.c:279
#, c-format
msgid "cannot open partition sector save file (%s)\n"
msgstr ""

#: fdisk/sfdisk.c:297
#, fuzzy, c-format
msgid "write error on %s\n"
msgstr "Fehler beim Schreiben auf %s\n"

#: fdisk/sfdisk.c:315
#, c-format
msgid "cannot stat partition restore file (%s)\n"
msgstr ""

#: fdisk/sfdisk.c:320
msgid "partition restore file has wrong size - not restoring\n"
msgstr ""

#: fdisk/sfdisk.c:324
#, fuzzy
msgid "out of memory?\n"
msgstr "Speicher ist alle\n"

#: fdisk/sfdisk.c:330
#, c-format
msgid "cannot open partition restore file (%s)\n"
msgstr ""

#: fdisk/sfdisk.c:336
#, fuzzy, c-format
msgid "error reading %s\n"
msgstr "Fehler beim Lesen von %s\n"

#: fdisk/sfdisk.c:343
#, fuzzy, c-format
msgid "cannot open device %s for writing\n"
msgstr "Konnte das Gerät %s nicht zum Schreiben öffnen\n"

#: fdisk/sfdisk.c:355
#, fuzzy, c-format
msgid "error writing sector %lu on %s\n"
msgstr "Fehler beim Schreiben des Sektors %lu auf %s\n"

#: fdisk/sfdisk.c:406
#, c-format
msgid "Disk %s: cannot get size\n"
msgstr ""

#: fdisk/sfdisk.c:411
#, c-format
msgid "Disk %s: cannot get geometry\n"
msgstr "Festplatte %s: Die Geometrie konnte nicht festgestellt werden\n"

#: fdisk/sfdisk.c:435
#, c-format
msgid ""
"Warning: start=%lu - this looks like a partition rather than\n"
"the entire disk. Using fdisk on it is probably meaningless.\n"
"[Use the --force option if you really want this]\n"
msgstr ""

#: fdisk/sfdisk.c:442
#, c-format
msgid "Warning: HDIO_GETGEO says that there are %lu heads\n"
msgstr ""

#: fdisk/sfdisk.c:445
#, c-format
msgid "Warning: HDIO_GETGEO says that there are %lu sectors\n"
msgstr ""

#: fdisk/sfdisk.c:449
#, c-format
msgid "Warning: BLKGETSIZE/HDIO_GETGEO says that there are %lu cylinders\n"
msgstr ""

#: fdisk/sfdisk.c:453
#, c-format
msgid ""
"Warning: unlikely number of sectors (%lu) - usually at most 63\n"
"This will give problems with all software that uses C/H/S addressing.\n"
msgstr ""

#: fdisk/sfdisk.c:457
#, fuzzy, c-format
msgid ""
"\n"
"Disk %s: %lu cylinders, %lu heads, %lu sectors/track\n"
msgstr ""
"\n"
"Festplatte %s: %lu Zylinder, %lu Köpfe, %lu Sektoren/Spur\n"
"\n"

#: fdisk/sfdisk.c:539
#, c-format
msgid ""
"%s of partition %s has impossible value for head: %lu (should be in 0-%lu)\n"
msgstr ""

#: fdisk/sfdisk.c:544
#, c-format
msgid ""
"%s of partition %s has impossible value for sector: %lu (should be in 1-%"
"lu)\n"
msgstr ""

#: fdisk/sfdisk.c:549
#, c-format
msgid ""
"%s of partition %s has impossible value for cylinders: %lu (should be in 0-%"
"lu)\n"
msgstr ""

#: fdisk/sfdisk.c:589
msgid ""
"Id  Name\n"
"\n"
msgstr ""
"Id  Name\n"
"\n"

#: fdisk/sfdisk.c:742
#, fuzzy
msgid "Re-reading the partition table ...\n"
msgstr "Die Partitionstabelle wird erneut gelesen ...\n"

#: fdisk/sfdisk.c:748
msgid ""
"The command to re-read the partition table failed\n"
"Reboot your system now, before using mkfs\n"
msgstr ""

#: fdisk/sfdisk.c:753
#, fuzzy, c-format
msgid "Error closing %s\n"
msgstr "Fehler beim Schließen von %s\n"

#: fdisk/sfdisk.c:791
#, c-format
msgid "%s: no such partition\n"
msgstr ""

#: fdisk/sfdisk.c:814
msgid "unrecognized format - using sectors\n"
msgstr ""

#: fdisk/sfdisk.c:853
#, fuzzy, c-format
msgid "# partition table of %s\n"
msgstr "# Partitionstabelle von %s\n"

#: fdisk/sfdisk.c:864
#, c-format
msgid "unimplemented format - using %s\n"
msgstr ""

#: fdisk/sfdisk.c:868
#, c-format
msgid ""
"Units = cylinders of %lu bytes, blocks of 1024 bytes, counting from %d\n"
"\n"
msgstr ""

#: fdisk/sfdisk.c:871
msgid "   Device Boot Start     End   #cyls   #blocks   Id  System\n"
msgstr ""

#: fdisk/sfdisk.c:876
#, c-format
msgid ""
"Units = sectors of 512 bytes, counting from %d\n"
"\n"
msgstr ""

#: fdisk/sfdisk.c:878
msgid "   Device Boot    Start       End  #sectors  Id  System\n"
msgstr ""

#: fdisk/sfdisk.c:881
#, c-format
msgid ""
"Units = blocks of 1024 bytes, counting from %d\n"
"\n"
msgstr ""

#: fdisk/sfdisk.c:883
msgid "   Device Boot   Start       End   #blocks   Id  System\n"
msgstr ""

#: fdisk/sfdisk.c:886
#, c-format
msgid ""
"Units = megabytes of 1048576 bytes, blocks of 1024 bytes, counting from %d\n"
"\n"
msgstr ""

#: fdisk/sfdisk.c:888
msgid "   Device Boot Start   End     MB   #blocks   Id  System\n"
msgstr ""

#: fdisk/sfdisk.c:1020
#, c-format
msgid "\t\tstart: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
msgstr ""

#: fdisk/sfdisk.c:1027
#, c-format
msgid "\t\tend: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
msgstr ""

#: fdisk/sfdisk.c:1030
#, c-format
msgid "partition ends on cylinder %ld, beyond the end of the disk\n"
msgstr ""

#: fdisk/sfdisk.c:1041
#, fuzzy
msgid "No partitions found\n"
msgstr "Keine Partitionen gefunden\n"

#: fdisk/sfdisk.c:1048
#, c-format
msgid ""
"Warning: The first partition looks like it was made\n"
"  for C/H/S=*/%ld/%ld (instead of %ld/%ld/%ld).\n"
"For this listing I'll assume that geometry.\n"
msgstr ""

#: fdisk/sfdisk.c:1098
msgid "no partition table present.\n"
msgstr ""

#: fdisk/sfdisk.c:1100
#, c-format
msgid "strange, only %d partitions defined.\n"
msgstr ""

#: fdisk/sfdisk.c:1109
#, c-format
msgid "Warning: partition %s has size 0 but is not marked Empty\n"
msgstr ""

#: fdisk/sfdisk.c:1112
#, c-format
msgid "Warning: partition %s has size 0 and is bootable\n"
msgstr ""

#: fdisk/sfdisk.c:1115
#, c-format
msgid "Warning: partition %s has size 0 and nonzero start\n"
msgstr ""

# XXX - Merge with next strings.
#: fdisk/sfdisk.c:1126
#, c-format
msgid "Warning: partition %s "
msgstr ""

#: fdisk/sfdisk.c:1127
#, c-format
msgid "is not contained in partition %s\n"
msgstr ""

# XXX - Merge with next strings.
#: fdisk/sfdisk.c:1138
#, c-format
msgid "Warning: partitions %s "
msgstr ""

#: fdisk/sfdisk.c:1139
#, c-format
msgid "and %s overlap\n"
msgstr ""

#: fdisk/sfdisk.c:1150
#, c-format
msgid ""
"Warning: partition %s contains part of the partition table (sector %lu),\n"
"and will destroy it when filled\n"
msgstr ""

#: fdisk/sfdisk.c:1162
#, fuzzy, c-format
msgid "Warning: partition %s starts at sector 0\n"
msgstr "Warnung: Partition %d fängt bei Sektor 0 an\n"

#: fdisk/sfdisk.c:1166
#, c-format
msgid "Warning: partition %s extends past end of disk\n"
msgstr ""

#: fdisk/sfdisk.c:1181
msgid ""
"Among the primary partitions, at most one can be extended\n"
" (although this is not a problem under Linux)\n"
msgstr ""

#: fdisk/sfdisk.c:1199
#, fuzzy, c-format
msgid "Warning: partition %s does not start at a cylinder boundary\n"
msgstr "Warnung: Partition %s beginnt nicht an einer Zylindergrenze\n"

#: fdisk/sfdisk.c:1205
#, fuzzy, c-format
msgid "Warning: partition %s does not end at a cylinder boundary\n"
msgstr "Warnung: Partition %s endet nicht an einer Zylindergrenze\n"

#: fdisk/sfdisk.c:1223
#, fuzzy
msgid ""
"Warning: more than one primary partition is marked bootable (active)\n"
"This does not matter for LILO, but the DOS MBR will not boot this disk.\n"
msgstr ""
"Warnung: Mehr als eine primäre Partition wurde als bootbar (aktiv) "
"markiert.\n"
"         Dies spielt bei LILO keine Rolle, aber der DOS MBR wird auf\n"
"         dieser Festplatte nicht booten.\n"

#: fdisk/sfdisk.c:1230
msgid ""
"Warning: usually one can boot from primary partitions only\n"
"LILO disregards the `bootable' flag.\n"
msgstr ""

#: fdisk/sfdisk.c:1236
#, fuzzy
msgid ""
"Warning: no primary partition is marked bootable (active)\n"
"This does not matter for LILO, but the DOS MBR will not boot this disk.\n"
msgstr ""
"Warnung: Keine primäre Partition wurde als bootbar (aktiv) markiert.\n"
"         Dies spielt bei LILO keine Rolle, aber der DOS MBR wird auf\n"
"         dieser Festplatte nicht booten.\n"

#: fdisk/sfdisk.c:1253
#, c-format
msgid ""
"partition %s: start: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
msgstr ""

#: fdisk/sfdisk.c:1262
#, c-format
msgid "partition %s: end: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n"
msgstr ""

#: fdisk/sfdisk.c:1265
#, c-format
msgid "partition %s ends on cylinder %ld, beyond the end of the disk\n"
msgstr ""

#: fdisk/sfdisk.c:1290
#, c-format
msgid ""
"Warning: shifted start of the extd partition from %ld to %ld\n"
"(For listing purposes only. Do not change its contents.)\n"
msgstr ""

# merge with next message!
#: fdisk/sfdisk.c:1296
#, fuzzy
msgid ""
"Warning: extended partition does not start at a cylinder boundary.\n"
"DOS and Linux will interpret the contents differently.\n"
msgstr "Warnung: erweiterte Partition beginnt nicht an einer Zylindergrenze\n"

#: fdisk/sfdisk.c:1314 fdisk/sfdisk.c:1391
#, c-format
msgid "too many partitions - ignoring those past nr (%d)\n"
msgstr ""

#: fdisk/sfdisk.c:1329
msgid "tree of partitions?\n"
msgstr ""

#: fdisk/sfdisk.c:1450
msgid "detected Disk Manager - unable to handle that\n"
msgstr ""

#: fdisk/sfdisk.c:1457
msgid "DM6 signature found - giving up\n"
msgstr ""

#: fdisk/sfdisk.c:1477
msgid "strange..., an extended partition of size 0?\n"
msgstr ""

#: fdisk/sfdisk.c:1484 fdisk/sfdisk.c:1495
msgid "strange..., a BSD partition of size 0?\n"
msgstr ""

#: fdisk/sfdisk.c:1529
#, c-format
msgid " %s: unrecognized partition\n"
msgstr ""

#: fdisk/sfdisk.c:1541
#, fuzzy
msgid "-n flag was given: Nothing changed\n"
msgstr "Die »-n«-Option wurde verwendet: Es wurde nichts verändert\n"

#: fdisk/sfdisk.c:1555
msgid "Failed saving the old sectors - aborting\n"
msgstr ""

#: fdisk/sfdisk.c:1560
#, c-format
msgid "Failed writing the partition on %s\n"
msgstr ""

#: fdisk/sfdisk.c:1637
msgid "long or incomplete input line - quitting\n"
msgstr ""

#: fdisk/sfdisk.c:1673
#, c-format
msgid "input error: `=' expected after %s field\n"
msgstr ""

#: fdisk/sfdisk.c:1680
#, c-format
msgid "input error: unexpected character %c after %s field\n"
msgstr ""

#: fdisk/sfdisk.c:1686
#, c-format
msgid "unrecognized input: %s\n"
msgstr ""

#: fdisk/sfdisk.c:1728
msgid "number too big\n"
msgstr ""

#: fdisk/sfdisk.c:1732
msgid "trailing junk after number\n"
msgstr ""

#: fdisk/sfdisk.c:1853
msgid "no room for partition descriptor\n"
msgstr ""

#: fdisk/sfdisk.c:1886
msgid "cannot build surrounding extended partition\n"
msgstr ""

#: fdisk/sfdisk.c:1937
msgid "too many input fields\n"
msgstr ""

#. no free blocks left - don't read any further
#: fdisk/sfdisk.c:1971
msgid "No room for more\n"
msgstr ""

#: fdisk/sfdisk.c:1990
msgid "Illegal type\n"
msgstr ""

#: fdisk/sfdisk.c:2022
#, c-format
msgid "Warning: given size (%lu) exceeds max allowable size (%lu)\n"
msgstr ""

#: fdisk/sfdisk.c:2028
msgid "Warning: empty partition\n"
msgstr ""

#: fdisk/sfdisk.c:2042
#, c-format
msgid "Warning: bad partition start (earliest %lu)\n"
msgstr ""

#: fdisk/sfdisk.c:2055
msgid "unrecognized bootable flag - choose - or *\n"
msgstr ""

#: fdisk/sfdisk.c:2072 fdisk/sfdisk.c:2085
msgid "partial c,h,s specification?\n"
msgstr ""

#: fdisk/sfdisk.c:2096
msgid "Extended partition not where expected\n"
msgstr ""

#: fdisk/sfdisk.c:2128
msgid "bad input\n"
msgstr ""

#: fdisk/sfdisk.c:2150
#, fuzzy
msgid "too many partitions\n"
msgstr "Zu viele Partitionen\n"

#: fdisk/sfdisk.c:2183
msgid ""
"Input in the following format; absent fields get a default value.\n"
"<start> <size> <type [E,S,L,X,hex]> <bootable [-,*]> <c,h,s> <c,h,s>\n"
"Usually you only need to specify <start> and <size> (and perhaps <type>).\n"
msgstr ""

#: fdisk/sfdisk.c:2203
msgid "version"
msgstr ""

#: fdisk/sfdisk.c:2209
#, c-format
msgid "Usage: %s [options] device ...\n"
msgstr ""

#: fdisk/sfdisk.c:2210
msgid "device: something like /dev/hda or /dev/sda"
msgstr ""

#: fdisk/sfdisk.c:2211
msgid "useful options:"
msgstr ""

#: fdisk/sfdisk.c:2212
msgid "    -s [or --show-size]: list size of a partition"
msgstr ""

#: fdisk/sfdisk.c:2213
msgid "    -c [or --id]:        print or change partition Id"
msgstr ""

#: fdisk/sfdisk.c:2214
msgid "    -l [or --list]:      list partitions of each device"
msgstr ""

#: fdisk/sfdisk.c:2215
msgid "    -d [or --dump]:      idem, but in a format suitable for later input"
msgstr ""

#: fdisk/sfdisk.c:2216
msgid "    -i [or --increment]: number cylinders etc. from 1 instead of from 0"
msgstr ""

#: fdisk/sfdisk.c:2217
msgid ""
"    -uS, -uB, -uC, -uM:  accept/report in units of sectors/blocks/cylinders/"
"MB"
msgstr ""

#: fdisk/sfdisk.c:2218
msgid "    -T [or --list-types]:list the known partition types"
msgstr ""

#: fdisk/sfdisk.c:2219
msgid "    -D [or --DOS]:       for DOS-compatibility: waste a little space"
msgstr ""

#: fdisk/sfdisk.c:2220
msgid "    -R [or --re-read]:   make kernel reread partition table"
msgstr ""

#: fdisk/sfdisk.c:2221
msgid "    -N# :                change only the partition with number #"
msgstr ""

#: fdisk/sfdisk.c:2222
msgid "    -n :                 do not actually write to disk"
msgstr ""

#: fdisk/sfdisk.c:2223
msgid ""
"    -O file :            save the sectors that will be overwritten to file"
msgstr ""

#: fdisk/sfdisk.c:2224
msgid "    -I file :            restore these sectors again"
msgstr ""

#: fdisk/sfdisk.c:2225
msgid "    -v [or --version]:   print version"
msgstr ""

#: fdisk/sfdisk.c:2226
msgid "    -? [or --help]:      print this message"
msgstr ""

#: fdisk/sfdisk.c:2227
msgid "dangerous options:"
msgstr ""

#: fdisk/sfdisk.c:2228
msgid "    -g [or --show-geometry]: print the kernel's idea of the geometry"
msgstr ""

#: fdisk/sfdisk.c:2229
msgid ""
"    -x [or --show-extended]: also list extended partitions on output\n"
"                             or expect descriptors for them on input"
msgstr ""

#: fdisk/sfdisk.c:2231
msgid ""
"    -L  [or --Linux]:      do not complain about things irrelevant for Linux"
msgstr ""

#: fdisk/sfdisk.c:2232
msgid "    -q  [or --quiet]:      suppress warning messages"
msgstr ""

#: fdisk/sfdisk.c:2233
msgid "    You can override the detected geometry using:"
msgstr ""

#: fdisk/sfdisk.c:2234
msgid "    -C# [or --cylinders #]:set the number of cylinders to use"
msgstr ""

#: fdisk/sfdisk.c:2235
msgid "    -H# [or --heads #]:    set the number of heads to use"
msgstr ""

#: fdisk/sfdisk.c:2236
msgid "    -S# [or --sectors #]:  set the number of sectors to use"
msgstr ""

#: fdisk/sfdisk.c:2237
msgid "You can disable all consistency checking with:"
msgstr ""

#: fdisk/sfdisk.c:2238
msgid "    -f  [or --force]:      do what I say, even if it is stupid"
msgstr ""

#: fdisk/sfdisk.c:2244
#, fuzzy
msgid "Usage:"
msgstr "Aufruf:"

#: fdisk/sfdisk.c:2245
#, c-format
msgid "%s device\t\t list active partitions on device\n"
msgstr ""

#: fdisk/sfdisk.c:2246
#, c-format
msgid "%s device n1 n2 ... activate partitions n1 ..., inactivate the rest\n"
msgstr ""

#: fdisk/sfdisk.c:2247
#, c-format
msgid "%s -An device\t activate partition n, inactivate the other ones\n"
msgstr ""

#: fdisk/sfdisk.c:2384
msgid "no command?\n"
msgstr ""

#: fdisk/sfdisk.c:2509
#, c-format
msgid "total: %d blocks\n"
msgstr ""

#: fdisk/sfdisk.c:2546
msgid "usage: sfdisk --print-id device partition-number\n"
msgstr ""

#: fdisk/sfdisk.c:2548
msgid "usage: sfdisk --change-id device partition-number Id\n"
msgstr ""

#: fdisk/sfdisk.c:2550
msgid "usage: sfdisk --id device partition-number [Id]\n"
msgstr ""

#: fdisk/sfdisk.c:2557
msgid "can specify only one device (except with -l or -s)\n"
msgstr ""

#: fdisk/sfdisk.c:2583
#, fuzzy, c-format
msgid "cannot open %s read-write\n"
msgstr "Konnte %s nicht öffnen\n"

#: fdisk/sfdisk.c:2585
#, fuzzy, c-format
msgid "cannot open %s for reading\n"
msgstr "Konnte %s nicht zum Lesen öffnen"

#: fdisk/sfdisk.c:2610
#, c-format
msgid "%s: OK\n"
msgstr "%s: OK\n"

# And again one for show_geometry()...
#: fdisk/sfdisk.c:2627
#, fuzzy, c-format
msgid "%s: %ld cylinders, %ld heads, %ld sectors/track\n"
msgstr "%s: %d Zylinder, %d Köpfe, %d Sektoren/Spur\n"

#: fdisk/sfdisk.c:2644
#, c-format
msgid "BLKGETSIZE ioctl failed for %s\n"
msgstr ""

#: fdisk/sfdisk.c:2721
#, c-format
msgid "bad active byte: 0x%x instead of 0x80\n"
msgstr ""

#: fdisk/sfdisk.c:2738 fdisk/sfdisk.c:2791 fdisk/sfdisk.c:2822
#, fuzzy
msgid ""
"Done\n"
"\n"
msgstr ""
"Fertig\n"
"\n"

#: fdisk/sfdisk.c:2747
#, c-format
msgid ""
"You have %d active primary partitions. This does not matter for LILO,\n"
"but the DOS MBR will only boot a disk with 1 active partition.\n"
msgstr ""

#: fdisk/sfdisk.c:2761
#, c-format
msgid "partition %s has id %x and is not hidden\n"
msgstr ""

#: fdisk/sfdisk.c:2818
#, c-format
msgid "Bad Id %lx\n"
msgstr ""

#: fdisk/sfdisk.c:2833
msgid "This disk is currently in use.\n"
msgstr ""

# This is a stat()
#: fdisk/sfdisk.c:2850
#, c-format
msgid "Fatal error: cannot find %s\n"
msgstr ""

#: fdisk/sfdisk.c:2853
#, c-format
msgid "Warning: %s is not a block device\n"
msgstr ""

#: fdisk/sfdisk.c:2859
msgid "Checking that no-one is using this disk right now ...\n"
msgstr ""

#: fdisk/sfdisk.c:2861
msgid ""
"\n"
"This disk is currently in use - repartitioning is probably a bad idea.\n"
"Umount all file systems, and swapoff all swap partitions on this disk.\n"
"Use the --no-reread flag to suppress this check.\n"
msgstr ""

#: fdisk/sfdisk.c:2865
msgid "Use the --force flag to overrule all checks.\n"
msgstr ""

#: fdisk/sfdisk.c:2869
msgid "OK\n"
msgstr "OK\n"

#: fdisk/sfdisk.c:2878
msgid "Old situation:\n"
msgstr ""

#: fdisk/sfdisk.c:2882
#, c-format
msgid "Partition %d does not exist, cannot change it\n"
msgstr ""

#: fdisk/sfdisk.c:2890
msgid "New situation:\n"
msgstr ""

#: fdisk/sfdisk.c:2895
msgid ""
"I don't like these partitions - nothing changed.\n"
"(If you really want this, use the --force option.)\n"
msgstr ""

#: fdisk/sfdisk.c:2898
msgid "I don't like this - probably you should answer No\n"
msgstr ""

#: fdisk/sfdisk.c:2903
msgid "Are you satisfied with this? [ynq] "
msgstr ""

#: fdisk/sfdisk.c:2905
msgid "Do you want to write this to disk? [ynq] "
msgstr ""

#: fdisk/sfdisk.c:2910
msgid ""
"\n"
"sfdisk: premature end of input\n"
msgstr ""

#: fdisk/sfdisk.c:2912
msgid "Quitting - nothing changed\n"
msgstr ""

#: fdisk/sfdisk.c:2918
msgid "Please answer one of y,n,q\n"
msgstr ""

#: fdisk/sfdisk.c:2926
#, fuzzy
msgid ""
"Successfully wrote the new partition table\n"
"\n"
msgstr ""
"Die neue Partitionstabelle wurde erfolgreich geschrieben\n"
"\n"

#: fdisk/sfdisk.c:2932
msgid ""
"If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)\n"
"to zero the first 512 bytes:  dd if=/dev/zero of=/dev/foo7 bs=512 count=1\n"
"(See fdisk(8).)\n"
msgstr ""

#: getopt-1.1.2/getopt.c:233
#, fuzzy
msgid "Try `getopt --help' for more information.\n"
msgstr "»getopt --help« gibt weitere Informationen.\n"

#: getopt-1.1.2/getopt.c:299
msgid "empty long option after -l or --long argument"
msgstr ""

#: getopt-1.1.2/getopt.c:319
#, fuzzy
msgid "unknown shell after -s or --shell argument"
msgstr "Unbekannte Shell als Argument von -s oder --shell"

#: getopt-1.1.2/getopt.c:324
#, fuzzy
msgid "Usage: getopt optstring parameters\n"
msgstr "Aufruf: getopt Optionszeichenkette Parameter\n"

#: getopt-1.1.2/getopt.c:325
#, fuzzy
msgid "       getopt [options] [--] optstring parameters\n"
msgstr "       getopt [Optionen] [--] Optionszeichenkette Parameter\n"

#: getopt-1.1.2/getopt.c:326
msgid "       getopt [options] -o|--options optstring [options] [--]\n"
msgstr ""

#: getopt-1.1.2/getopt.c:327
msgid "              parameters\n"
msgstr ""

#: getopt-1.1.2/getopt.c:328
msgid ""
"  -a, --alternative            Allow long options starting with single -\n"
msgstr ""

#: getopt-1.1.2/getopt.c:329
msgid "  -h, --help                   This small usage guide\n"
msgstr ""

#: getopt-1.1.2/getopt.c:330
msgid "  -l, --longoptions=longopts   Long options to be recognized\n"
msgstr ""

#: getopt-1.1.2/getopt.c:331
msgid ""
"  -n, --name=progname          The name under which errors are reported\n"
msgstr ""

#: getopt-1.1.2/getopt.c:332
msgid "  -o, --options=optstring      Short options to be recognized\n"
msgstr ""

#: getopt-1.1.2/getopt.c:333
msgid "  -q, --quiet                  Disable error reporting by getopt(3)\n"
msgstr ""

#: getopt-1.1.2/getopt.c:334
msgid "  -Q, --quiet-output           No normal output\n"
msgstr ""

#: getopt-1.1.2/getopt.c:335
msgid "  -s, --shell=shell            Set shell quoting conventions\n"
msgstr ""

#: getopt-1.1.2/getopt.c:336
msgid "  -T, --test                   Test for getopt(1) version\n"
msgstr ""

#: getopt-1.1.2/getopt.c:337
msgid "  -u, --unqote                 Do not quote the output\n"
msgstr ""

#: getopt-1.1.2/getopt.c:338
msgid "  -V, --version                Output version information\n"
msgstr ""

#: getopt-1.1.2/getopt.c:392 getopt-1.1.2/getopt.c:453
msgid "missing optstring argument"
msgstr ""

#: getopt-1.1.2/getopt.c:441
#, fuzzy
msgid "getopt (enhanced) 1.1.2\n"
msgstr "getopt (enhanced) 1.0.3\n"

#: getopt-1.1.2/getopt.c:447
#, fuzzy
msgid "internal error, contact the author."
msgstr "Interner Fehler, kontaktieren Sie den Autor."

#: hwclock/cmos.c:164
msgid "booted from MILO\n"
msgstr "von MILO gebootet\n"

#: hwclock/cmos.c:173
msgid "Ruffian BCD clock\n"
msgstr "Ruffian BCD Uhr\n"

# Egger
#: hwclock/cmos.c:189
#, fuzzy, c-format
msgid "clockport adjusted to 0x%x\n"
msgstr "Uhrport auf 0x%x gestellt\n"

# debug
#: hwclock/cmos.c:201
msgid "funky TOY!\n"
msgstr "»funky TOY«!\n"

# The second %s can be:
# "clock read"
# "set time"
#: hwclock/cmos.c:255
#, fuzzy, c-format
msgid "%s: atomic %s failed for 1000 iterations!"
msgstr "%s: atomares »%s« schlug 1000 Iterationen fehl!"

#: hwclock/cmos.c:579
#, c-format
msgid "Cannot open /dev/port: %s"
msgstr "Konnte /dev/port nicht öffnen: %s"

# typo in the english version: didn't
# Egger, not realy nice
#: hwclock/cmos.c:586
msgid "I failed to get permission because I didn't try.\n"
msgstr "Ich bekam keine Erlaubnis, weil ich es nicht versucht habe.\n"

# Egger
#: hwclock/cmos.c:589
#, c-format
msgid "%s is unable to get I/O port access:  the iopl(3) call failed.\n"
msgstr ""
"%s kann nicht auf I/O Port zugreifen: der iopl(3) Aufruf schlug fehl.\n"

# This is not the correct translation, but it
# explains the situation better.
#: hwclock/cmos.c:592
msgid "Probably you need root privileges.\n"
msgstr "Sie benötigen root-Rechte.\n"

# debug
#: hwclock/hwclock.c:219
#, c-format
msgid "Assuming hardware clock is kept in %s time.\n"
msgstr "Die Hardwareuhr läuft vermutlich in %s.\n"

#: hwclock/hwclock.c:220 hwclock/hwclock.c:314
msgid "UTC"
msgstr "UTC"

#: hwclock/hwclock.c:220 hwclock/hwclock.c:313
msgid "local"
msgstr "lokaler Zeit"

# merge with next
#: hwclock/hwclock.c:297
#, c-format
msgid "%s: Warning: unrecognized third line in adjtime file\n"
msgstr "%s: Warnung: Unbekannte dritte Zeile in der adjtime Datei\n"

#: hwclock/hwclock.c:299
msgid "(Expected: `UTC' or `LOCAL' or nothing.)\n"
msgstr "(Erwartet: »UTC« oder »LOCAL« oder nichts.)\n"

# XXX
#: hwclock/hwclock.c:308
#, fuzzy, c-format
msgid "Last drift adjustment done at %ld seconds after 1969\n"
msgstr "Letzte Abweichungskorrektur vorgenommen bei %d Sekunden nach 1969\n"

# XXX
#: hwclock/hwclock.c:310
#, fuzzy, c-format
msgid "Last calibration done at %ld seconds after 1969\n"
msgstr "Letzte Kalibrierung vorgenommen bei %d Sekunden nach 1969\n"

#: hwclock/hwclock.c:312
#, fuzzy, c-format
msgid "Hardware clock is on %s time\n"
msgstr "Hardwareuhr geht nach %s Zeit\n"

#: hwclock/hwclock.c:314
#, fuzzy
msgid "unknown"
msgstr "unbekannter"

# debug
# mmh.... sehr geehrter user... dieses ist keine werbeunterbrechung und
#   kein sendeausfall... ich wart nur auf das anbrechen der nächsten für mich
#   relevanten zeiteinheit.
# Egger
#. -----------------------------------------------------------------------------
#. Wait until the falling edge of the Hardware Clock's update flag so
#. that any time that is read from the clock immediately after we
#. return will be exact.
#.
#. The clock only has 1 second precision, so it gives the exact time only
#. once per second, right on the falling edge of the update flag.
#.
#. We wait (up to one second) either blocked waiting for an rtc device
#. or in a CPU spin loop.  The former is probably not very accurate.
#.
#. Return *retcode_p == 0 if it worked, nonzero if it didn't.
#.
#. -----------------------------------------------------------------------------
#: hwclock/hwclock.c:336
msgid "Waiting for clock tick...\n"
msgstr "Warte auf Uhrtick...\n"

# Egger
#: hwclock/hwclock.c:340
msgid "...got clock tick\n"
msgstr "... erhielt Uhrtick\n"

#: hwclock/hwclock.c:391
#, c-format
msgid "Invalid values in hardware clock: %4d/%.2d/%.2d %.2d:%.2d:%.2d\n"
msgstr "Ungültige Werte in Hardwareuhr: %4d/%.2d/%.2d %.2d:%.2d:%.2d\n"

#: hwclock/hwclock.c:399
#, c-format
msgid "Hw clock time : %4d/%.2d/%.2d %.2d:%.2d:%.2d = %ld seconds since 1969\n"
msgstr ""
"Zeit der Hardwareuhr: %4d/%.2d/%.2d %.2d:%.2d:%.2d = %ld Sekunden seit 1969\n"

# Egger
#: hwclock/hwclock.c:427
#, c-format
msgid "Time read from Hardware Clock: %4d/%.2d/%.2d %02d:%02d:%02d\n"
msgstr "Zeit gelesen aus Hardwareuhr: %4d/%.2d/%.2d %02d:%02d:%02d\n"

#: hwclock/hwclock.c:454
#, fuzzy, c-format
msgid "Setting Hardware Clock to %.2d:%.2d:%.2d = %ld seconds since 1969\n"
msgstr "Stelle die Hardwareuhr auf %.2d:%.2d:%.2d = %d Sekunden seit 1969\n"

#: hwclock/hwclock.c:460
msgid "Clock not changed - testing only.\n"
msgstr "Die Uhrzeit der Hardwareuhr wurde nicht verstellt - Testmodus.\n"

#: hwclock/hwclock.c:508
#, c-format
msgid ""
"Time elapsed since reference time has been %.6f seconds.\n"
"Delaying further to reach the next full second.\n"
msgstr ""
"Die vergangene Zeit seit der Referenzzeit waren %.6f Sekunden.\n"
"Es wird weiter gewartet, um die nächste ganze Sekunde zu erreichen.\n"

# Die Registereinträge der Hardwareuhr enthalten Werte, die ungültig
#   sind (z.B. der 50. Tag des Monats) oder ausserhalb des unterstützen
#   Bereiches (z.B. das Jahr 2095) liegen.
#: hwclock/hwclock.c:532
msgid ""
"The Hardware Clock registers contain values that are either invalid (e.g. "
"50th day of month) or beyond the range we can handle (e.g. Year 2095).\n"
msgstr ""
"Die Hardwareuhr enthält entweder ungültige Werte (z.B. den 50. Tag des\n"
"Monats), oder die Werte liegen außerhalb des Bereiches, der unterstützt\n"
"wird (z.B. das Jahr 2095).\n"

#: hwclock/hwclock.c:542
#, c-format
msgid "%s  %.6f seconds\n"
msgstr "%s  %.6f Sekunden\n"

#: hwclock/hwclock.c:576
msgid "No --date option specified.\n"
msgstr "Es wurde keine »--date«-Option angegeben.\n"

#: hwclock/hwclock.c:582
msgid "--date argument too long\n"
msgstr ""

# The english version is already a little misleading.
#: hwclock/hwclock.c:589
msgid ""
"The value of the --date option is not a valid date.\n"
"In particular, it contains quotation marks.\n"
msgstr ""
"Der Wert der »--date«-Option ist kein gültiges Datum.\n"
"Es darf kein Anführungszeichen enthalten.\n"

#: hwclock/hwclock.c:597
#, c-format
msgid "Issuing date command: %s\n"
msgstr "Der »date«-Befehl wird aufgerufen: %s\n"

#: hwclock/hwclock.c:601
msgid "Unable to run 'date' program in /bin/sh shell. popen() failed"
msgstr "Konnte »date« nicht in der /bin/sh-Shell starten. popen() schlug fehl"

#: hwclock/hwclock.c:609
#, c-format
msgid "response from date command = %s\n"
msgstr "Ausgabe des »date«-Befehls: %s\n"

#: hwclock/hwclock.c:611
#, c-format
msgid ""
"The date command issued by %s returned unexpected results.\n"
"The command was:\n"
"  %s\n"
"The response was:\n"
"  %s\n"
msgstr ""
"Der »date«-Befehl, der von %s aufgerufen wurde, lieferte\n"
"unerwartete Ergebnisse.\n"
"Der Befehl war:\n"
"  %s\n"
"Die Ausgabe war:\n"
"  %s\n"

#: hwclock/hwclock.c:623
#, fuzzy, c-format
msgid ""
"The date command issued by %s returned something other than an integer where "
"the converted time value was expected.\n"
"The command was:\n"
"  %s\n"
"The response was:\n"
" %s\n"
msgstr ""
"Der »date«-Befehl, der von %s aufgerufen wurde, lieferte\n"
"keine ganze Zahl, obwohl die umgewandelte Zeit erwartet wurde.\n"
"Der Befehl war:\n"
"  %s\n"
"Die Ausgabe war:\n"
"  %s\n"

# Egger, fixed %s->%d
#: hwclock/hwclock.c:634
#, fuzzy, c-format
msgid "date string %s equates to %ld seconds since 1969.\n"
msgstr "Die Zeichenkette %s entspricht %d Sekunden seit 1969.\n"

#: hwclock/hwclock.c:666
msgid ""
"The Hardware Clock does not contain a valid time, so we cannot set the "
"System Time from it.\n"
msgstr ""
"Die Hardwareuhr enthält eine ungültige Zeitangabe; aus diesem Grund ist\n"
"es nicht möglich, die Systemzeit zu setzen.\n"

# debug
#: hwclock/hwclock.c:688
msgid "Calling settimeofday:\n"
msgstr "settimeofday() wird aufgerufen:\n"

# not much to translate
# debug
#: hwclock/hwclock.c:689
#, c-format
msgid "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"
msgstr "\ttv.tv_sec = %ld, tv.tv_usec = %ld\n"

# not much to translate
# debug
#: hwclock/hwclock.c:691
#, c-format
msgid "\ttz.tz_minuteswest = %d\n"
msgstr "\ttz.tz_minuteswest = %d\n"

#: hwclock/hwclock.c:694
#, fuzzy
msgid "Not setting system clock because running in test mode.\n"
msgstr "Keine Änderung an der Systemuhr vorgenommen - Testmodus \n"

#: hwclock/hwclock.c:702
#, fuzzy
msgid "Must be superuser to set system clock.\n"
msgstr "Sie müssen root sein, um die Systemuhr zu verändern.\n"

#: hwclock/hwclock.c:704
msgid "settimeofday() failed"
msgstr "settimeofday() schlug fehl"

#: hwclock/hwclock.c:737
msgid ""
"Not adjusting drift factor because the Hardware Clock previously contained "
"garbage.\n"
msgstr ""
"Der Driftfaktor wird nicht verändert, da die Hardwareuhr vorher keinen "
"sinnvollen Wert enthielt.\n"

#: hwclock/hwclock.c:741
msgid ""
"Not adjusting drift factor because it has been less than a day since the "
"last calibration.\n"
msgstr ""
"Der Driftfaktor wird nicht verändert, da weniger als ein Tag seit der "
"letzten Kalibrierung vergangen ist.\n"

# Egger
#: hwclock/hwclock.c:750
#, c-format
msgid ""
"Clock drifted %d seconds in the past %d seconds in spite of a drift factor "
"of %f seconds/day.\n"
"Adjusting drift factor by %f seconds/day\n"
msgstr ""
"Die Uhr wich um %d Sekunden in den vergangenen %d Sekunden, trotz eines "
"Driftfaktors von %f Sekunden/Tag, ab.\n"
"Der Faktor wird um %f Sekunden/Tag geändert.\n"

# Egger
#: hwclock/hwclock.c:801
#, c-format
msgid "Time since last adjustment is %d seconds\n"
msgstr "Es vergingen %d Sekunden seit der letzten Anpassung.\n"

# Egger
#: hwclock/hwclock.c:803
#, c-format
msgid "Need to insert %d seconds and refer time back %.6f seconds ago\n"
msgstr ""
"Es müssen %d Sekunden eingefügt werden und es muss auf die Zeit vor %.6f "
"Sekunden zugegriffen werden\n"

# merge with next
#: hwclock/hwclock.c:832
msgid "Not updating adjtime file because of testing mode.\n"
msgstr "Die adjtime Datei wird nicht aktualisiert - Testmodus \n"

# "Hätte das folgende in die Datei %s geschrieben:\n"
# passiv, Konjunktiv in der Umschreibungsform
#: hwclock/hwclock.c:833
#, c-format
msgid ""
"Would have written the following to %s:\n"
"%s"
msgstr ""
"Folgendes wäre in die Datei %s geschrieben worden:\n"
"%s"

# "Abweichungsparameter"
#: hwclock/hwclock.c:857
msgid "Drift adjustment parameters not updated.\n"
msgstr "Die Abweichungsparameter wurden nicht verändert.\n"

# "anpassen"
#: hwclock/hwclock.c:898
msgid ""
"The Hardware Clock does not contain a valid time, so we cannot adjust it.\n"
msgstr ""
"Die Hardwareuhr enthält keine gültige Zeit, deshalb kann sie nicht angepasst "
"werden.\n"

# "Justierung"
#: hwclock/hwclock.c:922
msgid "Needed adjustment is less than one second, so not setting clock.\n"
msgstr ""
"Da die Anpassung weniger als eine Sekunde betragen hätte, wird sie nicht "
"durchgeführt.\n"

#: hwclock/hwclock.c:948
#, c-format
msgid "Using %s.\n"
msgstr "Benutze %s.\n"

# "Schnittstelle"
#: hwclock/hwclock.c:950
msgid "No usable clock interface found.\n"
msgstr "Keine brauchbare Uhrschnittstelle gefunden.\n"

# "stellen"
#: hwclock/hwclock.c:1045
msgid "Unable to set system clock.\n"
msgstr "Konnte die Systemuhr nicht stellen.\n"

#: hwclock/hwclock.c:1076
msgid ""
"The kernel keeps an epoch value for the Hardware Clock only on an Alpha "
"machine.\n"
"This copy of hwclock was built for a machine other than Alpha\n"
"(and thus is presumably not running on an Alpha now).  No action taken.\n"
msgstr ""

# Egger
#: hwclock/hwclock.c:1085
msgid "Unable to get the epoch value from the kernel.\n"
msgstr "Kann den Epochenwert nicht vom Kernel bekommen.\n"

# Egger
# "Epochenwert"
#: hwclock/hwclock.c:1087
#, c-format
msgid "Kernel is assuming an epoch value of %lu\n"
msgstr "Kernel geht von einem Epochenwert von %lu aus.\n"

#: hwclock/hwclock.c:1090
msgid ""
"To set the epoch value, you must use the 'epoch' option to tell to what "
"value to set it.\n"
msgstr ""
"Um den Epochenwert zu ändern, müssen sie die »epoch«-Option benutzen, um "
"anzugeben auf welchen Wert er gesetzt werden soll.\n"

#: hwclock/hwclock.c:1093
#, c-format
msgid "Not setting the epoch to %d - testing only.\n"
msgstr "Der Epochenwert wird nicht auf %d gesetzt - Testmodus.\n"

# Egger
#: hwclock/hwclock.c:1096
msgid "Unable to set the epoch value in the kernel.\n"
msgstr "Kann den Epochenwert im Kernel nicht ändern.\n"

# "Universalzeit"
#: hwclock/hwclock.c:1125
#, fuzzy, c-format
msgid ""
"hwclock - query and set the hardware clock (RTC)\n"
"\n"
"Usage: hwclock [function] [options...]\n"
"\n"
"Functions:\n"
"  --help        show this help\n"
"  --show        read hardware clock and print result\n"
"  --set         set the rtc to the time given with --date\n"
"  --hctosys     set the system time from the hardware clock\n"
"  --systohc     set the hardware clock to the current system time\n"
"  --adjust      adjust the rtc to account for systematic drift since \n"
"                the clock was last set or adjusted\n"
"  --getepoch    print out the kernel's hardware clock epoch value\n"
"  --setepoch    set the kernel's hardware clock epoch value to the \n"
"                value given with --epoch\n"
"  --version     print out the version of hwclock to stdout\n"
"\n"
"Options: \n"
"  --utc         the hardware clock is kept in coordinated universal time\n"
"  --localtime   the hardware clock is kept in local time\n"
"  --directisa   access the ISA bus directly instead of %s\n"
"  --badyear     ignore rtc's year because the bios is broken\n"
"  --date        specifies the time to which to set the hardware clock\n"
"  --epoch=year  specifies the year which is the beginning of the \n"
"                hardware clock's epoch value\n"
"  --noadjfile   do not access /etc/adjtime. Requires the use of\n"
"                either --utc or --localtime\n"
msgstr ""
"hwclock - Die Hardwareuhr setzen und abfragen\n"
"\n"
"Aufruf: hwclock [Funktion] [Optionen...]\n"
"\n"
"Funktionen:\n"
"  --help        zeigt diese Hilfe\n"
"  --show        zeigt Zeit der Hardwareuhr an\n"
"  --set         setzt die Hardwareuhr auf die Zeit die mit der\n"
"                »--date«-Option angegeben wurde\n"
"  --hctosys     setzt die Systemzeit von der Hardwareuhr\n"
"  --systohc     setzt die Hardwareuhr auf die Systemzeit\n"
"  --adjust      passt die Hardwareuhr um einen berechneten \n"
"                Driftfaktor an\n"
"  --getepoch    zeigt den Epochenwert der Hardwareuhr an\n"
"  --setepoch    stellt den Epochenwert der Hardwareuhr auf den Wert,\n"
"                der mit der »--epoch«-Option angegeben wurde\n"
"  --version     zeigt die Version von hwclock an\n"
"\n"
"Optionen: \n"
"  --utc         die Hardwareuhr läuft nach Universalzeit (UTC)\n"
"  --localtime   die Hardwareuhr läuft nach lokaler Zeit\n"
"  --directisa   verwendet den ISA Bus direkt anstelle von %s\n"
"  --badyear     ignoriert die Jahreszahl der Hardwareuhr,\n"
"                weil sie nicht stimmt (Jahr2000 Problem)\n"
"  --date        verwendet dieses Datum\n"
"  --epoch=year  verwendet diesen Wert als Epochenwert\n"

#: hwclock/hwclock.c:1152
msgid ""
"  --jensen, --arc, --srm, --funky-toy\n"
"                tell hwclock the type of alpha you have (see hwclock(8))\n"
msgstr ""

#: hwclock/hwclock.c:1257
#, c-format
msgid "%s takes no non-option arguments.  You supplied %d.\n"
msgstr ""

#: hwclock/hwclock.c:1267
msgid ""
"You have specified multiple function options.\n"
"You can only perform one function at a time.\n"
msgstr ""

#: hwclock/hwclock.c:1273
#, c-format
msgid ""
"%s: The --utc and --localtime options are mutually exclusive.  You specified "
"both.\n"
msgstr ""

#: hwclock/hwclock.c:1279
#, c-format
msgid ""
"%s: The --adjust and --noadjfile options are mutually exclusive.  You "
"specified both.\n"
msgstr ""

#: hwclock/hwclock.c:1285
#, c-format
msgid "%s: With --noadjfile, you must specify either --utc or --localtime\n"
msgstr ""

#: hwclock/hwclock.c:1298
msgid "No usable set-to time.  Cannot set clock.\n"
msgstr ""

#: hwclock/hwclock.c:1313
#, fuzzy
msgid "Sorry, only the superuser can change the Hardware Clock.\n"
msgstr "Sie müssen root sein, um die Hardwareuhr zu ändern.\n"

#: hwclock/hwclock.c:1317
#, fuzzy
msgid "Sorry, only the superuser can change the System Clock.\n"
msgstr "Sie müssen root sein, um die Systemuhr zu ändern.\n"

#: hwclock/hwclock.c:1321
msgid ""
"Sorry, only the superuser can change the Hardware Clock epoch in the "
"kernel.\n"
msgstr "Sie müssen root sein, um den »epoch«-Wert zu ändern.\n"

#: hwclock/hwclock.c:1341
msgid "Cannot access the Hardware Clock via any known method.\n"
msgstr ""
"Es wurde keine Zugriffsart gefunden, mit der auf die Hardwareuhr zugegriffen "
"werden konnte.\n"

#: hwclock/hwclock.c:1344
msgid ""
"Use the --debug option to see the details of our search for an access "
"method.\n"
msgstr ""
"Benutzen Sie die »--debug«-Option um die versuchten Zugriffsarten "
"anzuzeigen.\n"

# debug
#: hwclock/kd.c:42
msgid "Waiting in loop for time from KDGHWCLK to change\n"
msgstr ""

#: hwclock/kd.c:45
msgid "KDGHWCLK ioctl to read time failed"
msgstr ""
"KDGHWCLK ioctl scheiterte beim Versuch die Zeit aus der Hardwareuhr "
"auszulesen."

#: hwclock/kd.c:66 hwclock/rtc.c:174
msgid "Timed out waiting for time change.\n"
msgstr ""

#: hwclock/kd.c:70
msgid "KDGHWCLK ioctl to read time failed in loop"
msgstr ""
"KDGHWCLK ioctl scheiterte beim Versuch die Zeit aus der Hardwareuhr "
"auszulesen."

#: hwclock/kd.c:92
#, fuzzy, c-format
msgid "ioctl() failed to read time from %s"
msgstr "ioctl() konnte Zeit nicht von /dev/tty1 lesen."

#: hwclock/kd.c:128
msgid "ioctl KDSHWCLK failed"
msgstr ""

#: hwclock/kd.c:165
#, fuzzy
msgid "Can't open /dev/tty1 or /dev/vc/1"
msgstr "Konnte /dev/tty1 nicht öffnen"

#: hwclock/kd.c:170
msgid "KDGHWCLK ioctl failed"
msgstr ""

#: hwclock/rtc.c:136
#, c-format
msgid "ioctl() to %s to read the time failed.\n"
msgstr ""

#: hwclock/rtc.c:158
#, c-format
msgid "Waiting in loop for time from %s to change\n"
msgstr ""

#: hwclock/rtc.c:195 hwclock/rtc.c:250
#, c-format
msgid "open() of %s failed"
msgstr "Konnte %s nicht öffnen"

#: hwclock/rtc.c:213
#, c-format
msgid "%s does not have interrupt functions. "
msgstr ""

#: hwclock/rtc.c:222
#, c-format
msgid "read() to %s to wait for clock tick failed"
msgstr ""

#: hwclock/rtc.c:231
#, c-format
msgid "ioctl() to %s to turn off update interrupts failed"
msgstr ""

#: hwclock/rtc.c:234
#, c-format
msgid "ioctl() to %s to turn on update interrupts failed unexpectedly"
msgstr ""

#: hwclock/rtc.c:274 hwclock/rtc.c:358 hwclock/rtc.c:404
#, c-format
msgid "Unable to open %s"
msgstr "Konnte %s nicht öffnen"

#: hwclock/rtc.c:300
#, c-format
msgid "ioctl() to %s to set the time failed.\n"
msgstr ""

# debug
#: hwclock/rtc.c:306
#, c-format
msgid "ioctl(%s) was successful.\n"
msgstr "»ioctl(%s)« war erfolgreich.\n"

#: hwclock/rtc.c:335
#, c-format
msgid "Open of %s failed"
msgstr "Konnte %s nicht öffnen"

#: hwclock/rtc.c:353 hwclock/rtc.c:399
#, c-format
msgid ""
"To manipulate the epoch value in the kernel, we must access the Linux 'rtc' "
"device driver via the device special file %s.  This file does not exist on "
"this system.\n"
msgstr ""

#: hwclock/rtc.c:365
#, c-format
msgid "ioctl(RTC_EPOCH_READ) to %s failed"
msgstr ""

#: hwclock/rtc.c:371
#, c-format
msgid "we have read epoch %ld from %s with RTC_EPOCH_READ ioctl.\n"
msgstr ""

#. kernel would not accept this epoch value
#. Hmm - bad habit, deciding not to do what the user asks
#. just because one believes that the kernel might not like it.
#: hwclock/rtc.c:391
#, c-format
msgid "The epoch value may not be less than 1900.  You requested %ld\n"
msgstr ""

#: hwclock/rtc.c:409
#, c-format
msgid "setting epoch to %ld with RTC_EPOCH_SET ioctl to %s.\n"
msgstr ""

#: hwclock/rtc.c:414
#, c-format
msgid ""
"The kernel device driver for %s does not have the RTC_EPOCH_SET ioctl.\n"
msgstr ""

#: hwclock/rtc.c:417
#, c-format
msgid "ioctl(RTC_EPOCH_SET) to %s failed"
msgstr ""

#: hwclock/shhopt.c:255 hwclock/shhopt.c:281
#, c-format
msgid "invalid number `%s'\n"
msgstr "Ungültige Zahl: »%s«\n"

#: hwclock/shhopt.c:258 hwclock/shhopt.c:284
#, fuzzy, c-format
msgid "number `%s' to `%s' out of range\n"
msgstr "Die Zahl »%s« für die Option »%s« ist außerhalb des Bereiches\n"

#: hwclock/shhopt.c:398
#, c-format
msgid "unrecognized option `%s'\n"
msgstr "unbekannte Option »%s«\n"

# libc: "Die Option »%s« erfordert ein Argument\n"
#: hwclock/shhopt.c:411 hwclock/shhopt.c:449
#, c-format
msgid "option `%s' requires an argument\n"
msgstr "Option »%s« erwartet ein Argument\n"

# libc: "Die Option »%s« erlaubt kein Argument\n"
#: hwclock/shhopt.c:417
#, c-format
msgid "option `%s' doesn't allow an argument\n"
msgstr "Option »%s« erwartet kein Argument\n"

#: hwclock/shhopt.c:439
#, c-format
msgid "unrecognized option `-%c'\n"
msgstr "unbekannte Option »-%c«\n"

#: login-utils/agetty.c:312
msgid "calling open_tty\n"
msgstr ""

#. Initialize the termio settings (raw mode, eight-bit, blocking i/o).
#: login-utils/agetty.c:325
msgid "calling termio_init\n"
msgstr ""

#: login-utils/agetty.c:330
msgid "writing init string\n"
msgstr ""

#. Optionally detect the baud rate from the modem status message.
#: login-utils/agetty.c:340
msgid "before autobaud\n"
msgstr ""

#: login-utils/agetty.c:352
msgid "waiting for cr-lf\n"
msgstr ""

#: login-utils/agetty.c:356
#, c-format
msgid "read %c\n"
msgstr ""

#. Read the login name.
#: login-utils/agetty.c:365
msgid "reading login name\n"
msgstr ""

#: login-utils/agetty.c:386
#, c-format
msgid "%s: can't exec %s: %m"
msgstr "%s: Fehler beim Ausführen von %s: %m"

#: login-utils/agetty.c:406
msgid "can't malloc initstring"
msgstr "Konnte keinen Speicher für den »initstring« reservieren"

#: login-utils/agetty.c:471
#, c-format
msgid "bad timeout value: %s"
msgstr ""

#: login-utils/agetty.c:480
msgid "after getopt loop\n"
msgstr ""

#: login-utils/agetty.c:530
msgid "exiting parseargs\n"
msgstr ""

#: login-utils/agetty.c:542
msgid "entered parse_speeds\n"
msgstr ""

#: login-utils/agetty.c:545
#, c-format
msgid "bad speed: %s"
msgstr "falsche Geschwindigkeit: %s"

#: login-utils/agetty.c:547
msgid "too many alternate speeds"
msgstr ""

#: login-utils/agetty.c:549
msgid "exiting parsespeeds\n"
msgstr ""

#: login-utils/agetty.c:642
#, c-format
msgid "/dev: chdir() failed: %m"
msgstr "Konnte nicht in das Verzeichnis /dev wechseln: %m"

#: login-utils/agetty.c:646
#, c-format
msgid "/dev/%s: not a character device"
msgstr "/dev/%s ist kein zeichenorientiertes Gerät"

# debug
#. ignore close(2) errors
#: login-utils/agetty.c:653
msgid "open(2)\n"
msgstr ""

#: login-utils/agetty.c:655
#, c-format
msgid "/dev/%s: cannot open as standard input: %m"
msgstr "Konnte /dev/%s nicht als Standardeingabe öffnen: %m"

#: login-utils/agetty.c:665
#, c-format
msgid "%s: not open for read/write"
msgstr ""

#. Set up standard output and standard error file descriptors.
#: login-utils/agetty.c:669
msgid "duping\n"
msgstr ""

#. set up stdout and stderr
#: login-utils/agetty.c:671
#, c-format
msgid "%s: dup problem: %m"
msgstr ""

#: login-utils/agetty.c:745
msgid "term_io 2\n"
msgstr ""

#: login-utils/agetty.c:930
msgid "user"
msgstr "Benutzer"

#: login-utils/agetty.c:930
msgid "users"
msgstr "Benutzer"

#: login-utils/agetty.c:1018
#, c-format
msgid "%s: read: %m"
msgstr ""

#: login-utils/agetty.c:1064
#, c-format
msgid "%s: input overrun"
msgstr ""

#: login-utils/agetty.c:1188
#, c-format
msgid ""
"Usage: %s [-hiLmw] [-l login_program] [-t timeout] [-I initstring] [-H "
"login_host] baud_rate,... line [termtype]\n"
"or\t[-hiLmw] [-l login_program] [-t timeout] [-I initstring] [-H login_host] "
"line baud_rate,... [termtype]\n"
msgstr ""

#: login-utils/checktty.c:104 login-utils/checktty.c:125
msgid "login: memory low, login may fail\n"
msgstr ""

# This ends up in the syslog. Translate it?
#: login-utils/checktty.c:105
msgid "can't malloc for ttyclass"
msgstr ""

# This ends up in the syslog. Translate it?
#: login-utils/checktty.c:126
msgid "can't malloc for grplist"
msgstr ""

#. there was a default rule, but user didn't match, reject!
#: login-utils/checktty.c:422
#, c-format
msgid "Login on %s from %s denied by default.\n"
msgstr ""

#. if we get here, /etc/usertty exists, there's a line
#. matching our username, but it doesn't contain the
#. name of the tty where the user is trying to log in.
#. So deny access!
#: login-utils/checktty.c:433
#, c-format
msgid "Login on %s from %s denied.\n"
msgstr ""

#: login-utils/chfn.c:122 login-utils/chsh.c:107
#, c-format
msgid "%s: you (user %d) don't exist.\n"
msgstr ""

#: login-utils/chfn.c:129 login-utils/chsh.c:114
#, c-format
msgid "%s: user \"%s\" does not exist.\n"
msgstr ""

#: login-utils/chfn.c:134 login-utils/chsh.c:119
#, c-format
msgid "%s: can only change local entries; use yp%s instead.\n"
msgstr ""

#: login-utils/chfn.c:146
#, c-format
msgid "Changing finger information for %s.\n"
msgstr ""

#: login-utils/chfn.c:152 login-utils/chfn.c:156 login-utils/chfn.c:163
#: login-utils/chfn.c:167 login-utils/chsh.c:143 login-utils/chsh.c:147
#: login-utils/chsh.c:154 login-utils/chsh.c:158
msgid "Password error."
msgstr ""

#: login-utils/chfn.c:176 login-utils/chsh.c:167 login-utils/login.c:775
#: login-utils/newgrp.c:48 login-utils/simpleinit.c:320 mount/lomount.c:248
#: mount/lomount.c:253
msgid "Password: "
msgstr "Passwort: "

#: login-utils/chfn.c:179 login-utils/chsh.c:170
msgid "Incorrect password."
msgstr ""

#: login-utils/chfn.c:190
msgid "Finger information not changed.\n"
msgstr ""

# XXX - Merge with next strings.
#: login-utils/chfn.c:292
#, c-format
msgid "Usage: %s [ -f full-name ] [ -o office ] "
msgstr ""

#: login-utils/chfn.c:293
msgid ""
"[ -p office-phone ]\n"
"\t[ -h home-phone ] "
msgstr ""

#: login-utils/chfn.c:294
msgid "[ --help ] [ --version ]\n"
msgstr ""

#: login-utils/chfn.c:365 login-utils/chsh.c:278
msgid ""
"\n"
"Aborted.\n"
msgstr ""

#: login-utils/chfn.c:398
msgid "field is too long.\n"
msgstr ""

#: login-utils/chfn.c:406
#, c-format
msgid "'%c' is not allowed.\n"
msgstr ""

#: login-utils/chfn.c:411
msgid "Control characters are not allowed.\n"
msgstr ""

#: login-utils/chfn.c:476
msgid "Finger information *NOT* changed.  Try again later.\n"
msgstr ""

#: login-utils/chfn.c:479
msgid "Finger information changed.\n"
msgstr ""

#: login-utils/chfn.c:493 login-utils/chsh.c:393 sys-utils/cytune.c:328
#, fuzzy
msgid "malloc failed"
msgstr "»malloc« schlug fehl"

#: login-utils/chsh.c:130
#, c-format
msgid "%s: Your shell is not in /etc/shells, shell change denied\n"
msgstr ""

#: login-utils/chsh.c:137
#, c-format
msgid "Changing shell for %s.\n"
msgstr ""

#: login-utils/chsh.c:178
msgid "New shell"
msgstr ""

#: login-utils/chsh.c:185
msgid "Shell not changed.\n"
msgstr ""

#: login-utils/chsh.c:192
msgid "Shell *NOT* changed.  Try again later.\n"
msgstr ""

#: login-utils/chsh.c:195
msgid "Shell changed.\n"
msgstr ""

#: login-utils/chsh.c:260
#, c-format
msgid ""
"Usage: %s [ -s shell ] [ --list-shells ] [ --help ] [ --version ]\n"
"       [ username ]\n"
msgstr ""
"Aufruf: %s [ -s Shell ] [ --list-shells ] [ --help ] [ --version ]\n"
"        [ Benutzername ]\n"

#: login-utils/chsh.c:303
#, c-format
msgid "%s: shell must be a full path name.\n"
msgstr ""

#: login-utils/chsh.c:307
#, c-format
msgid "%s: \"%s\" does not exist.\n"
msgstr ""

#: login-utils/chsh.c:311
#, c-format
msgid "%s: \"%s\" is not executable.\n"
msgstr ""

#: login-utils/chsh.c:318
#, c-format
msgid "%s: '%c' is not allowed.\n"
msgstr ""

#: login-utils/chsh.c:322
#, c-format
msgid "%s: Control characters are not allowed.\n"
msgstr ""

#: login-utils/chsh.c:329
#, c-format
msgid "Warning: \"%s\" is not listed in /etc/shells\n"
msgstr ""

#: login-utils/chsh.c:331
#, c-format
msgid "%s: \"%s\" is not listed in /etc/shells.\n"
msgstr ""

#: login-utils/chsh.c:333
#, c-format
msgid "%s: use -l option to see list\n"
msgstr ""

#: login-utils/chsh.c:339
#, c-format
msgid "Warning: \"%s\" is not listed in /etc/shells.\n"
msgstr ""

#: login-utils/chsh.c:340
#, c-format
msgid "Use %s -l to see list.\n"
msgstr ""

#: login-utils/chsh.c:360
msgid "No known shells.\n"
msgstr ""

#: login-utils/cryptocard.c:68
#, fuzzy
msgid "couldn't open /dev/urandom"
msgstr "Konnte /dev/urandom nicht öffnen"

#: login-utils/cryptocard.c:73
msgid "couldn't read random data from /dev/urandom"
msgstr ""

#: login-utils/cryptocard.c:96
#, fuzzy, c-format
msgid "can't open %s for reading"
msgstr "Konnte %s nicht zum Lesen öffnen"

#: login-utils/cryptocard.c:100
#, c-format
msgid "can't stat(%s)"
msgstr ""

#: login-utils/cryptocard.c:106
#, c-format
msgid "%s doesn't have the correct filemodes"
msgstr ""

#: login-utils/cryptocard.c:111
#, c-format
msgid "can't read data from %s"
msgstr ""

#: login-utils/islocal.c:38
#, c-format
msgid "Can't read %s, exiting."
msgstr ""

#: login-utils/last.c:148
msgid "usage: last [-#] [-f file] [-t tty] [-h hostname] [user ...]\n"
msgstr ""

#: login-utils/last.c:312
msgid "  still logged in"
msgstr ""

#: login-utils/last.c:340
#, c-format
msgid ""
"\n"
"wtmp begins %s"
msgstr ""

#: login-utils/last.c:396 login-utils/last.c:414 login-utils/last.c:465
msgid "last: malloc failure.\n"
msgstr ""

#: login-utils/last.c:441
msgid "last: gethostname"
msgstr ""

#: login-utils/last.c:490
#, c-format, ycp-format
msgid ""
"\n"
"interrupted %10.10s %5.5s \n"
msgstr ""

#: login-utils/login.c:402
msgid "login: -h for super-user only.\n"
msgstr ""

#: login-utils/login.c:429
msgid "usage: login [-fp] [username]\n"
msgstr "Aufruf: login [-fp] [Benutzername]\n"

#: login-utils/login.c:538
#, c-format
msgid "login: PAM Failure, aborting: %s\n"
msgstr ""

#: login-utils/login.c:540
#, c-format
msgid "Couldn't initialize PAM: %s"
msgstr ""

#.
#. * Andrew.Taylor@cal.montage.ca: Provide a user prompt to PAM
#. * so that the "login: " prompt gets localized. Unfortunately,
#. * PAM doesn't have an interface to specify the "Password: " string
#. * (yet).
#.
#: login-utils/login.c:557
msgid "login: "
msgstr "Anmeldung: "

#: login-utils/login.c:597
#, c-format
msgid "FAILED LOGIN %d FROM %s FOR %s, %s"
msgstr ""

#: login-utils/login.c:601
msgid ""
"Login incorrect\n"
"\n"
msgstr ""

#: login-utils/login.c:610
#, c-format
msgid "TOO MANY LOGIN TRIES (%d) FROM %s FOR %s, %s"
msgstr ""

#: login-utils/login.c:614
#, c-format
msgid "FAILED LOGIN SESSION FROM %s FOR %s, %s"
msgstr ""

#: login-utils/login.c:618
msgid ""
"\n"
"Login incorrect\n"
msgstr ""

#: login-utils/login.c:639 login-utils/login.c:646 login-utils/login.c:678
msgid ""
"\n"
"Session setup problem, abort.\n"
msgstr ""

#: login-utils/login.c:640
#, c-format
msgid "NULL user name in %s:%d. Abort."
msgstr ""

#: login-utils/login.c:647
#, c-format
msgid "Invalid user name \"%s\" in %s:%d. Abort."
msgstr ""

#: login-utils/login.c:664
#, fuzzy
msgid "login: Out of memory\n"
msgstr "%s: Speicher ist alle!\n"

#: login-utils/login.c:710
msgid "Illegal username"
msgstr ""

#: login-utils/login.c:753
#, c-format
msgid "%s login refused on this terminal.\n"
msgstr ""

#: login-utils/login.c:758
#, c-format
msgid "LOGIN %s REFUSED FROM %s ON TTY %s"
msgstr ""

#: login-utils/login.c:762
#, c-format
msgid "LOGIN %s REFUSED ON TTY %s"
msgstr ""

#: login-utils/login.c:815
msgid "Login incorrect\n"
msgstr ""

#: login-utils/login.c:837
msgid ""
"Too many users logged on already.\n"
"Try again later.\n"
msgstr ""

#: login-utils/login.c:841
msgid "You have too many processes running.\n"
msgstr ""

#: login-utils/login.c:1073
#, c-format
msgid "DIALUP AT %s BY %s"
msgstr ""

#: login-utils/login.c:1080
#, c-format
msgid "ROOT LOGIN ON %s FROM %s"
msgstr ""

#: login-utils/login.c:1083
#, c-format
msgid "ROOT LOGIN ON %s"
msgstr ""

#: login-utils/login.c:1086
#, c-format
msgid "LOGIN ON %s BY %s FROM %s"
msgstr ""

#: login-utils/login.c:1089
#, c-format
msgid "LOGIN ON %s BY %s"
msgstr ""

#: login-utils/login.c:1101
#, fuzzy
msgid "You have new mail.\n"
msgstr "Sie haben %sE-Mail.\n"

#: login-utils/login.c:1103
#, fuzzy
msgid "You have mail.\n"
msgstr "Sie haben %sE-Mail.\n"

#. error in fork()
#: login-utils/login.c:1129
#, c-format
msgid "login: failure forking: %s"
msgstr "login: Kann keinen neuen Prozess erzeugen: %s"

#: login-utils/login.c:1151
msgid "setuid() failed"
msgstr ""

#: login-utils/login.c:1157
#, c-format
msgid "No directory %s!\n"
msgstr "Konnte nicht in das Verzeichnis %s wechseln!\n"

#: login-utils/login.c:1161
msgid "Logging in with home = \"/\".\n"
msgstr ""

#: login-utils/login.c:1169
msgid "login: no memory for shell script.\n"
msgstr ""

#: login-utils/login.c:1196
#, c-format
msgid "login: couldn't exec shell script: %s.\n"
msgstr ""

#: login-utils/login.c:1199
#, c-format
msgid "login: no shell: %s.\n"
msgstr ""

#: login-utils/login.c:1214
#, c-format
msgid ""
"\n"
"%s login: "
msgstr ""
"\n"
"%s Anmeldung: "

#: login-utils/login.c:1225
msgid "login name much too long.\n"
msgstr ""

#: login-utils/login.c:1226
msgid "NAME too long"
msgstr ""

#: login-utils/login.c:1233
msgid "login names may not start with '-'.\n"
msgstr "Benutzernamen dürfen nicht mit einem »-« anfangen.\n"

#: login-utils/login.c:1243
msgid "too many bare linefeeds.\n"
msgstr ""

#: login-utils/login.c:1244
msgid "EXCESSIVE linefeeds"
msgstr ""

#: login-utils/login.c:1255
#, c-format
msgid "Login timed out after %d seconds\n"
msgstr ""

#: login-utils/login.c:1352
#, c-format
msgid "Last login: %.*s "
msgstr "Letzte Anmeldung: %.*s "

#: login-utils/login.c:1356
#, c-format
msgid "from %.*s\n"
msgstr "von %.*s\n"

#: login-utils/login.c:1359
#, c-format
msgid "on %.*s\n"
msgstr "auf %.*s\n"

# This ends up in the syslog. Translate it?
#: login-utils/login.c:1379
#, c-format
msgid "LOGIN FAILURE FROM %s, %s"
msgstr ""

# This ends up in the syslog. Translate it?
#: login-utils/login.c:1382
#, c-format
msgid "LOGIN FAILURE ON %s, %s"
msgstr ""

# This ends up in the syslog. Translate it?
#: login-utils/login.c:1386
#, c-format
msgid "%d LOGIN FAILURES FROM %s, %s"
msgstr ""

# This ends up in the syslog. Translate it?
#: login-utils/login.c:1389
#, c-format
msgid "%d LOGIN FAILURES ON %s, %s"
msgstr ""

#: login-utils/mesg.c:89
msgid "is y\n"
msgstr ""

#: login-utils/mesg.c:92
msgid "is n\n"
msgstr ""

#: login-utils/mesg.c:112
msgid "usage: mesg [y | n]\n"
msgstr "Aufruf: mesg [y | n]\n"

#: login-utils/newgrp.c:68
msgid "newgrp: Who are you?"
msgstr ""

#: login-utils/newgrp.c:76 login-utils/newgrp.c:86
msgid "newgrp: setgid"
msgstr ""

#: login-utils/newgrp.c:81
msgid "newgrp: No such group."
msgstr ""

# libc.po: "Keine Berechtigung"
#: login-utils/newgrp.c:90
#, fuzzy
msgid "newgrp: Permission denied"
msgstr "newgrp: Zugriff verweigert"

#: login-utils/newgrp.c:97
msgid "newgrp: setuid"
msgstr ""

#: login-utils/newgrp.c:103
msgid "No shell"
msgstr ""

#: login-utils/passwd.c:161
msgid "The password must have at least 6 characters, try again.\n"
msgstr ""

#: login-utils/passwd.c:174
msgid ""
"The password must contain characters out of two of the following\n"
"classes:  upper and lower case letters, digits and non alphanumeric\n"
"characters. See passwd(1) for more information.\n"
msgstr ""

#: login-utils/passwd.c:183
msgid "You cannot reuse the old password.\n"
msgstr ""

#: login-utils/passwd.c:188
msgid "Please don't use something like your username as password!\n"
msgstr ""

#: login-utils/passwd.c:199 login-utils/passwd.c:206
msgid "Please don't use something like your realname as password!\n"
msgstr ""

#: login-utils/passwd.c:224
msgid "Usage: passwd [username [password]]\n"
msgstr ""

#: login-utils/passwd.c:225
msgid "Only root may use the one and two argument forms.\n"
msgstr ""

#: login-utils/passwd.c:279
msgid "Usage: passwd [-foqsvV] [user [password]]\n"
msgstr ""

#: login-utils/passwd.c:300
#, c-format
msgid "Can't exec %s: %s\n"
msgstr ""

#: login-utils/passwd.c:311
msgid "Cannot find login name"
msgstr ""

#: login-utils/passwd.c:318 login-utils/passwd.c:325
msgid "Only root can change the password for others.\n"
msgstr ""

#: login-utils/passwd.c:333
msgid "Too many arguments.\n"
msgstr ""

#: login-utils/passwd.c:338
#, c-format
msgid "Can't find username anywhere. Is `%s' really a user?"
msgstr ""

#: login-utils/passwd.c:342
msgid "Sorry, I can only change local passwords. Use yppasswd instead."
msgstr ""

#: login-utils/passwd.c:348
msgid "UID and username does not match, imposter!"
msgstr ""

#: login-utils/passwd.c:353
#, c-format
msgid "Changing password for %s\n"
msgstr ""

#: login-utils/passwd.c:357
msgid "Enter old password: "
msgstr ""

#: login-utils/passwd.c:359
msgid "Illegal password, imposter."
msgstr ""

#: login-utils/passwd.c:371
msgid "Enter new password: "
msgstr ""

#: login-utils/passwd.c:373
msgid "Password not changed."
msgstr ""

#: login-utils/passwd.c:382
msgid "Re-type new password: "
msgstr ""

#: login-utils/passwd.c:385
msgid "You misspelled it. Password not changed."
msgstr ""

#: login-utils/passwd.c:400
#, c-format
msgid "password changed, user %s"
msgstr ""

#: login-utils/passwd.c:403
msgid "ROOT PASSWORD CHANGED"
msgstr ""

#: login-utils/passwd.c:405
#, c-format
msgid "password changed by root, user %s"
msgstr ""

#: login-utils/passwd.c:412
msgid "calling setpwnam to set password.\n"
msgstr ""

#: login-utils/passwd.c:416
msgid "Password *NOT* changed.  Try again later.\n"
msgstr ""

#: login-utils/passwd.c:422
msgid "Password changed.\n"
msgstr ""

#: login-utils/shutdown.c:113
msgid "Usage: shutdown [-h|-r] [-fqs] [now|hh:ss|+mins]\n"
msgstr ""

#: login-utils/shutdown.c:131
msgid "Shutdown process aborted"
msgstr ""

#: login-utils/shutdown.c:162
#, c-format
msgid "%s: Only root can shut a system down.\n"
msgstr ""

#: login-utils/shutdown.c:256
msgid "That must be tomorrow, can't you wait till then?\n"
msgstr ""

#: login-utils/shutdown.c:307
msgid "for maintenance; bounce, bounce"
msgstr ""

# debug
#: login-utils/shutdown.c:311
#, c-format
msgid "timeout = %d, quiet = %d, reboot = %d\n"
msgstr "timeout = %d, quiet = %d, reboot = %d\n"

#: login-utils/shutdown.c:336
msgid "The system is being shut down within 5 minutes"
msgstr ""

#: login-utils/shutdown.c:340
msgid "Login is therefore prohibited."
msgstr ""

#: login-utils/shutdown.c:362
#, c-format
msgid "rebooted by %s: %s"
msgstr ""

#: login-utils/shutdown.c:365
#, c-format
msgid "halted by %s: %s"
msgstr ""

#. RB_AUTOBOOT
#: login-utils/shutdown.c:429
msgid ""
"\n"
"Why am I still alive after reboot?"
msgstr ""

#: login-utils/shutdown.c:431
msgid ""
"\n"
"Now you can turn off the power..."
msgstr ""

#: login-utils/shutdown.c:447
msgid "Calling kernel power-off facility...\n"
msgstr ""

#: login-utils/shutdown.c:450
#, c-format
msgid "Error powering off\t%s\n"
msgstr ""

#: login-utils/shutdown.c:458
#, c-format
msgid "Executing the program \"%s\" ...\n"
msgstr ""

#: login-utils/shutdown.c:461
#, c-format
msgid "Error executing\t%s\n"
msgstr ""

# XXX - Have to look at other OSs translation for Broadcast
# Message
#. gettext crashes on \a
#: login-utils/shutdown.c:488
#, fuzzy, c-format
msgid "URGENT: broadcast message from %s:"
msgstr "Rundsendenachricht von %s@%s"

#: login-utils/shutdown.c:494
#, c-format
msgid "System going down in %d hours %d minutes"
msgstr ""

#: login-utils/shutdown.c:497
#, c-format
msgid "System going down in 1 hour %d minutes"
msgstr ""

#: login-utils/shutdown.c:500
#, c-format
msgid "System going down in %d minutes\n"
msgstr ""

#: login-utils/shutdown.c:503
msgid "System going down in 1 minute\n"
msgstr ""

#: login-utils/shutdown.c:505
msgid "System going down IMMEDIATELY!\n"
msgstr ""

#: login-utils/shutdown.c:510
#, c-format
msgid "\t... %s ...\n"
msgstr ""

#: login-utils/shutdown.c:567
msgid "Cannot fork for swapoff. Shrug!"
msgstr ""

#: login-utils/shutdown.c:575
msgid "Cannot exec swapoff, hoping umount will do the trick."
msgstr ""

#: login-utils/shutdown.c:594
msgid "Cannot fork for umount, trying manually."
msgstr ""

#: login-utils/shutdown.c:603
#, c-format
msgid "Cannot exec %s, trying umount.\n"
msgstr ""

#: login-utils/shutdown.c:607
msgid "Cannot exec umount, giving up on umount."
msgstr ""

#: login-utils/shutdown.c:612
msgid "Unmounting any remaining filesystems..."
msgstr ""

#: login-utils/shutdown.c:648
#, fuzzy, c-format
msgid "shutdown: Couldn't umount %s: %s\n"
msgstr "shutdown: konnte %s nicht umounten: %s\n"

#: login-utils/simpleinit.c:128
msgid "Booting to single user mode.\n"
msgstr ""

#: login-utils/simpleinit.c:132
msgid "exec of single user shell failed\n"
msgstr ""

#: login-utils/simpleinit.c:136
msgid "fork of single user shell failed\n"
msgstr ""

#: login-utils/simpleinit.c:204
msgid "error opening fifo\n"
msgstr "Fehler beim Öffnen der »fifo«\n"

#: login-utils/simpleinit.c:242
msgid "error running finalprog\n"
msgstr ""

#. Error
#: login-utils/simpleinit.c:246
msgid "error forking finalprog\n"
msgstr ""

#: login-utils/simpleinit.c:325
msgid ""
"\n"
"Wrong password.\n"
msgstr ""
"\n"
"Falsches Passwort.\n"

#: login-utils/simpleinit.c:398
msgid "lstat of path failed\n"
msgstr ""

#: login-utils/simpleinit.c:406
msgid "stat of path failed\n"
msgstr ""

#: login-utils/simpleinit.c:414
msgid "open of directory failed\n"
msgstr ""

#: login-utils/simpleinit.c:481
msgid "fork failed\n"
msgstr ""

#: login-utils/simpleinit.c:512 text-utils/more.c:1624
msgid "exec failed\n"
msgstr "»exec()« schlug fehl\n"

#: login-utils/simpleinit.c:536
#, fuzzy
msgid "cannot open inittab\n"
msgstr "Konnte inittab nicht öffnen\n"

#: login-utils/simpleinit.c:603
msgid "no TERM or cannot stat tty\n"
msgstr ""

#: login-utils/simpleinit.c:909
#, fuzzy, c-format
msgid "error stopping service: \"%s\""
msgstr "Fehler beim Schreiben von %s: %s"

#: login-utils/ttymsg.c:75
msgid "too many iov's (change code in wall/ttymsg.c)"
msgstr ""

#: login-utils/ttymsg.c:85
msgid "excessively long line arg"
msgstr ""

# This is only used, when strerror(errno) is much too long
#: login-utils/ttymsg.c:139
msgid "cannot fork"
msgstr "Kann keinen neuen Prozess erzeugen (fork)"

# This is used normaly
#: login-utils/ttymsg.c:143
#, c-format
msgid "fork: %s"
msgstr "Prozesserzeugung (fork): %s"

#: login-utils/ttymsg.c:171
#, c-format
msgid "%s: BAD ERROR"
msgstr ""

#: login-utils/vipw.c:139
#, c-format
msgid "%s: the password file is busy.\n"
msgstr ""

#: login-utils/vipw.c:142
#, c-format
msgid "%s: the group file is busy.\n"
msgstr ""

#: login-utils/vipw.c:158
#, c-format
msgid "%s: the %s file is busy (%s present)\n"
msgstr ""

#: login-utils/vipw.c:164
#, c-format
msgid "%s: can't link %s: %s\n"
msgstr ""

#: login-utils/vipw.c:195
#, c-format
msgid "%s: can't unlock %s: %s (your changes are still in %s)\n"
msgstr ""

#: login-utils/vipw.c:218
#, c-format
msgid "%s: Cannot fork\n"
msgstr "%s: Kann keinen neuen Prozess erzeugen (fork)\n"

# "nicht geändert"
# "wurde nicht geändert"
#: login-utils/vipw.c:254
#, fuzzy, c-format
msgid "%s: %s unchanged\n"
msgstr "%s: %s unverändert\n"

#: login-utils/vipw.c:273
#, c-format
msgid "%s: no changes made\n"
msgstr ""

#: login-utils/vipw.c:328
msgid "You are using shadow groups on this system.\n"
msgstr ""

#: login-utils/vipw.c:329
msgid "You are using shadow passwords on this system.\n"
msgstr ""

#: login-utils/vipw.c:330
#, c-format
msgid "Would you like to edit %s now [y/n]? "
msgstr ""

#: login-utils/wall.c:104
#, c-format
msgid "usage: %s [file]\n"
msgstr "Aufruf: %s [Datei]\n"

#: login-utils/wall.c:159
#, c-format
msgid "%s: can't open temporary file.\n"
msgstr "%s: Konnte eine temporäre Datei nicht öffnen.\n"

# XXX - Have to look at other OSs translation for Broadcast
# Message
#: login-utils/wall.c:186
#, c-format
msgid "Broadcast Message from %s@%s"
msgstr "Rundsendenachricht von %s@%s"

#: login-utils/wall.c:204
#, c-format
msgid "%s: will not read %s - use stdin.\n"
msgstr ""

#: login-utils/wall.c:209
#, c-format
msgid "%s: can't read %s.\n"
msgstr "%s: Konnte %s nicht lesen.\n"

#: login-utils/wall.c:231
#, c-format
msgid "%s: can't stat temporary file.\n"
msgstr "%s: Konnte »stat« nicht auf eine temporäre Datei anwenden.\n"

#: login-utils/wall.c:241
#, c-format
msgid "%s: can't read temporary file.\n"
msgstr "%s: Konnte eine temporäre Datei nicht lesen.\n"

#: misc-utils/cal.c:241
msgid "illegal month value: use 1-12"
msgstr ""

#: misc-utils/cal.c:245
msgid "illegal year value: use 1-9999"
msgstr ""

#. %s is the month name, %d the year number.
#. * you can change the order and/or add something her; eg for
#. * Basque the translation should be: "%2$dko %1$s", and
#. * the Vietnamese should be "%s na(m %d", etc.
#.
#: misc-utils/cal.c:352
#, c-format
msgid "%s %d"
msgstr ""

#: misc-utils/cal.c:647
msgid "usage: cal [-mjyV] [[month] year]\n"
msgstr "Aufruf: cal [-mjyV] [[Monat] Jahr]\n"

#: misc-utils/ddate.c:205
#, c-format
msgid "usage: %s [+format] [day month year]\n"
msgstr "Aufruf: %s [+Format] [Tag Monat Jahr]\n"

#. handle St. Tib's Day
#: misc-utils/ddate.c:252
msgid "St. Tib's Day"
msgstr ""

#: misc-utils/kill.c:206
#, c-format
msgid "%s: unknown signal %s\n"
msgstr "%s: Unbekanntes Signal %s\n"

#: misc-utils/kill.c:269
#, c-format
msgid "%s: can't find process \"%s\"\n"
msgstr "%s: Konnte den Prozess »%s« nicht finden.\n"

#: misc-utils/kill.c:313
#, c-format
msgid "%s: unknown signal %s; valid signals:\n"
msgstr "%s: Unbekanntes Signal %s; gültige Signale:\n"

#: misc-utils/kill.c:353
#, c-format
msgid "usage: %s [ -s signal | -p ] [ -a ] pid ...\n"
msgstr "Aufruf: %s [ -s Signal | -p ] [ -a ] PID ...\n"

#: misc-utils/kill.c:354
#, c-format
msgid "       %s -l [ signal ]\n"
msgstr "        %s -l [ Signal ]\n"

#: misc-utils/logger.c:140
#, c-format
msgid "logger: %s: %s.\n"
msgstr "logger: Konnte %s nicht öffnen: %s.\n"

#: misc-utils/logger.c:247
#, c-format
msgid "logger: unknown facility name: %s.\n"
msgstr "logger: Unbekannter »Facility«-Name: %s.\n"

#: misc-utils/logger.c:259
#, c-format
msgid "logger: unknown priority name: %s.\n"
msgstr "logger: Unbekannter Prioritätsname: %s.\n"

#: misc-utils/logger.c:286
msgid ""
"usage: logger [-is] [-f file] [-p pri] [-t tag] [-u socket] [ message ... ]\n"
msgstr ""
"Aufruf: logger [-is] [-f Datei] [-p Pri] [-t Tag] [-u Socket] "
"[ Meldung ... ]\n"

#: misc-utils/look.c:348
msgid "usage: look [-dfa] [-t char] string [file]\n"
msgstr "Aufruf: look [-dfa] [-t Endzeichen] Zeichenkette [Datei]\n"

#: misc-utils/mcookie.c:122 misc-utils/mcookie.c:149
#, c-format
msgid "Could not open %s\n"
msgstr "Konnte %s nicht öffnen\n"

#: misc-utils/mcookie.c:126 misc-utils/mcookie.c:145
#, c-format
msgid "Got %d bytes from %s\n"
msgstr "%d Bytes aus %s gelesen\n"

#: misc-utils/namei.c:102
#, c-format
msgid "namei: unable to get current directory - %s\n"
msgstr "namei: Konnte das aktuelle Verzeichnis nicht feststellen: %s\n"

#: misc-utils/namei.c:115
#, c-format
msgid "namei: unable to chdir to %s - %s (%d)\n"
msgstr "namei: Konnte nicht in das Verzeichnis %s wechseln - %s (%d)\n"

#: misc-utils/namei.c:125
msgid "usage: namei [-mx] pathname [pathname ...]\n"
msgstr "Aufruf: namei [-mx] Dateiname [Dateiname ...]\n"

#: misc-utils/namei.c:150
msgid "namei: could not chdir to root!\n"
msgstr "namei: Konnte nicht in das root-Verzeichnis wechseln!\n"

# XXX
#: misc-utils/namei.c:157
msgid "namei: could not stat root!\n"
msgstr ""

#: misc-utils/namei.c:171
#, fuzzy
msgid "namei: buf overflow\n"
msgstr "  Überlauf\n"

#: misc-utils/namei.c:217
#, c-format
msgid " ? could not chdir into %s - %s (%d)\n"
msgstr " ? Konnte nicht in das Verzeichnis %s wechseln - %s (%d)\n"

#: misc-utils/namei.c:246
#, c-format
msgid " ? problems reading symlink %s - %s (%d)\n"
msgstr " ? Probleme beim Lesen der symbolischen Verknüpfung %s - %s (%d)\n"

#: misc-utils/namei.c:256
msgid "  *** EXCEEDED UNIX LIMIT OF SYMLINKS ***\n"
msgstr ""
"  *** Die maximale Zahl der symbolischen Verknüpfungen wurde überschritten "
"***\n"

#: misc-utils/namei.c:293
#, c-format
msgid "namei: unknown file type 0%06o on file %s\n"
msgstr "namei: Unbekannter Dateityp 0%06o der Datei %s\n"

#: misc-utils/rename.c:38
#, c-format
msgid "%s: out of memory\n"
msgstr "%s: Speicher ist alle!\n"

#: misc-utils/rename.c:56
#, c-format
msgid "%s: renaming %s to %s failed: %s\n"
msgstr "%s: Konnte %s nicht in %s umbenennen: %s\n"

#: misc-utils/rename.c:86
#, c-format
msgid "call: %s from to files...\n"
msgstr ""

#: misc-utils/script.c:106
#, c-format
msgid ""
"Warning: `%s' is a symlink.\n"
"Use `%s [options] %s' if you really want to use it.\n"
"Script not started.\n"
msgstr ""

#: misc-utils/script.c:155
#, fuzzy
msgid "usage: script [-a] [-f] [-q] [-t] [file]\n"
msgstr "Aufruf: script [-a] [-f] [-q] [Datei]\n"

# Not realy nice...
#: misc-utils/script.c:178
#, c-format
msgid "Script started, file is %s\n"
msgstr "»Script« wurde gestartet, die Datei ist %s\n"

# The %s must be at the end, cause it contains the \n
#: misc-utils/script.c:254
#, c-format
msgid "Script started on %s"
msgstr "»Script« wurde gestartet: %s"

# The %s must be at the end, cause it contains the \n
#: misc-utils/script.c:325
#, c-format
msgid ""
"\n"
"Script done on %s"
msgstr ""
"\n"
"»Script« beendet: %s"

#: misc-utils/script.c:333
#, c-format
msgid "Script done, file is %s\n"
msgstr "»Script« wurde beendet, die Datei ist %s\n"

#: misc-utils/script.c:344
msgid "openpty failed\n"
msgstr "»openpty« ist fehlgeschlagen\n"

#: misc-utils/script.c:378
msgid "Out of pty's\n"
msgstr "Keine ptys mehr.\n"

#. Print error message about arguments, and the command's syntax.
#: misc-utils/setterm.c:743
#, c-format
msgid "%s: Argument error, usage\n"
msgstr "%s: Fehler bei den Argumenten; Aufruf:\n"

#: misc-utils/setterm.c:746
msgid "  [ -term terminal_name ]\n"
msgstr "  [ -term Terminalname ]\n"

#: misc-utils/setterm.c:747
msgid "  [ -reset ]\n"
msgstr "  [ -reset ]\n"

#: misc-utils/setterm.c:748
msgid "  [ -initialize ]\n"
msgstr "  [ -initialize ]\n"

#: misc-utils/setterm.c:749
msgid "  [ -cursor [on|off] ]\n"
msgstr "  [ -cursor [on|off] ]\n"

#: misc-utils/setterm.c:751
msgid "  [ -snow [on|off] ]\n"
msgstr "  [ -snow [on|off] ]\n"

#: misc-utils/setterm.c:752
msgid "  [ -softscroll [on|off] ]\n"
msgstr "  [ -softscroll [on|off] ]\n"

#: misc-utils/setterm.c:754
msgid "  [ -repeat [on|off] ]\n"
msgstr "  [ -repeat [on|off] ]\n"

#: misc-utils/setterm.c:755
msgid "  [ -appcursorkeys [on|off] ]\n"
msgstr "  [ -appcursorkeys [on|off] ]\n"

#: misc-utils/setterm.c:756
msgid "  [ -linewrap [on|off] ]\n"
msgstr "  [ -linewrap [on|off] ]\n"

#: misc-utils/setterm.c:757
msgid "  [ -default ]\n"
msgstr "  [ -default ]\n"

#: misc-utils/setterm.c:758
msgid "  [ -foreground black|blue|green|cyan"
msgstr "  [ -foreground black|blue|green|cyan"

#: misc-utils/setterm.c:759 misc-utils/setterm.c:761
msgid "|red|magenta|yellow|white|default ]\n"
msgstr "|red|magenta|yellow|white|default ]\n"

#: misc-utils/setterm.c:760
msgid "  [ -background black|blue|green|cyan"
msgstr "  [ -background black|blue|green|cyan"

#: misc-utils/setterm.c:762
msgid "  [ -ulcolor black|grey|blue|green|cyan"
msgstr "  [ -ulcolor black|grey|blue|green|cyan"

#: misc-utils/setterm.c:763 misc-utils/setterm.c:765 misc-utils/setterm.c:767
#: misc-utils/setterm.c:769
msgid "|red|magenta|yellow|white ]\n"
msgstr "|red|magenta|yellow|white ]\n"

#: misc-utils/setterm.c:764
msgid "  [ -ulcolor bright blue|green|cyan"
msgstr "  [ -ulcolor bright blue|green|cyan"

#: misc-utils/setterm.c:766
msgid "  [ -hbcolor black|grey|blue|green|cyan"
msgstr "  [ -hbcolor black|grey|blue|green|cyan"

#: misc-utils/setterm.c:768
msgid "  [ -hbcolor bright blue|green|cyan"
msgstr "  [ -hbcolor bright blue|green|cyan"

#: misc-utils/setterm.c:771
msgid "  [ -standout [ attr ] ]\n"
msgstr "  [ -standout [ Attribut ] ]\n"

#: misc-utils/setterm.c:773
msgid "  [ -inversescreen [on|off] ]\n"
msgstr "  [ -inversescreen [on|off] ]\n"

#: misc-utils/setterm.c:774
msgid "  [ -bold [on|off] ]\n"
msgstr "  [ -bold [on|off] ]\n"

#: misc-utils/setterm.c:775
msgid "  [ -half-bright [on|off] ]\n"
msgstr "  [ -half-bright [on|off] ]\n"

#: misc-utils/setterm.c:776
msgid "  [ -blink [on|off] ]\n"
msgstr "  [ -blink [on|off] ]\n"

#: misc-utils/setterm.c:777
msgid "  [ -reverse [on|off] ]\n"
msgstr "  [ -reverse [on|off] ]\n"

#: misc-utils/setterm.c:778
msgid "  [ -underline [on|off] ]\n"
msgstr "  [ -underline [on|off] ]\n"

#: misc-utils/setterm.c:779
msgid "  [ -store ]\n"
msgstr "  [ -store ]\n"

#: misc-utils/setterm.c:780
msgid "  [ -clear [all|rest] ]\n"
msgstr "  [ -clear [all|rest] ]\n"

#: misc-utils/setterm.c:781
msgid "  [ -tabs [ tab1 tab2 tab3 ... ] ]      (tabn = 1-160)\n"
msgstr "  [ -tabs [ tab1 tab2 tab3 ... ] ]      (tabN = 1-160)\n"

#: misc-utils/setterm.c:782
msgid "  [ -clrtabs [ tab1 tab2 tab3 ... ] ]   (tabn = 1-160)\n"
msgstr "  [ -clrtabs [ tab1 tab2 tab3 ... ] ]   (tabN = 1-160)\n"

#: misc-utils/setterm.c:783
msgid "  [ -regtabs [1-160] ]\n"
msgstr "  [ -regtabs [1-160] ]\n"

#: misc-utils/setterm.c:784
msgid "  [ -blank [0-60] ]\n"
msgstr "  [ -blank [0-60] ]\n"

#: misc-utils/setterm.c:785
msgid "  [ -dump   [1-NR_CONSOLES] ]\n"
msgstr "  [ -dump   [1-Anzahl_Konsolen] ]\n"

#: misc-utils/setterm.c:786
msgid "  [ -append [1-NR_CONSOLES] ]\n"
msgstr "  [ -append [1-Anzahl_Konsolen] ]\n"

#: misc-utils/setterm.c:787
msgid "  [ -file dumpfilename ]\n"
msgstr "  [ -file Dumpdateiname ]\n"

#: misc-utils/setterm.c:788
msgid "  [ -msg [on|off] ]\n"
msgstr "  [ -msg [on|off] ]\n"

#: misc-utils/setterm.c:789
msgid "  [ -msglevel [0-8] ]\n"
msgstr "  [ -msglevel [0-8] ]\n"

#: misc-utils/setterm.c:790
msgid "  [ -powersave [on|vsync|hsync|powerdown|off] ]\n"
msgstr "  [ -powersave [on|vsync|hsync|powerdown|off] ]\n"

#: misc-utils/setterm.c:791
msgid "  [ -powerdown [0-60] ]\n"
msgstr "  [ -powerdown [0-60] ]\n"

#: misc-utils/setterm.c:792
msgid "  [ -blength [0-2000] ]\n"
msgstr "  [ -blength [0-2000] ]\n"

#: misc-utils/setterm.c:793
#, fuzzy
msgid "  [ -bfreq freqnumber ]\n"
msgstr "  [ -bfreq Freqnummer ]\n"

#: misc-utils/setterm.c:1047
msgid "cannot (un)set powersave mode\n"
msgstr ""

#: misc-utils/setterm.c:1086 misc-utils/setterm.c:1094
#, c-format
msgid "klogctl error: %s\n"
msgstr "»klogctl« Fehler: %s\n"

#: misc-utils/setterm.c:1133
#, c-format
msgid "Error reading %s\n"
msgstr "Fehler beim Lesen von %s\n"

#: misc-utils/setterm.c:1148
msgid "Error writing screendump\n"
msgstr "Fehler beim Schreiben des Bildschirmdumps\n"

#: misc-utils/setterm.c:1162
#, c-format
msgid "couldn't read %s, and cannot ioctl dump\n"
msgstr ""

#: misc-utils/setterm.c:1228
#, c-format
msgid "%s: $TERM is not defined.\n"
msgstr "%s: Die Umgebungsvariable TERM ist nicht gesetzt.\n"

#: misc-utils/whereis.c:157
msgid "whereis [ -sbmu ] [ -SBM dir ... -f ] name...\n"
msgstr "whereis [ -sbmu ] [ -SBM Verzeichnis ... -f ] Name...\n"

#: misc-utils/write.c:99
msgid "write: can't find your tty's name\n"
msgstr ""

#: misc-utils/write.c:110
msgid "write: you have write permission turned off.\n"
msgstr ""

#: misc-utils/write.c:131
#, c-format
msgid "write: %s is not logged in on %s.\n"
msgstr ""

#: misc-utils/write.c:139
#, c-format
msgid "write: %s has messages disabled on %s\n"
msgstr ""

#: misc-utils/write.c:146
msgid "usage: write user [tty]\n"
msgstr ""

#: misc-utils/write.c:234
#, c-format
msgid "write: %s is not logged in\n"
msgstr ""

#: misc-utils/write.c:243
#, c-format
msgid "write: %s has messages disabled\n"
msgstr ""

#: misc-utils/write.c:247
#, c-format
msgid "write: %s is logged in more than once; writing to %s\n"
msgstr ""

#: misc-utils/write.c:313
#, c-format
msgid "Message from %s@%s (as %s) on %s at %s ..."
msgstr ""

#: misc-utils/write.c:316
#, c-format
msgid "Message from %s@%s on %s at %s ..."
msgstr ""

#: mount/fstab.c:113
#, c-format
msgid "warning: error reading %s: %s"
msgstr "Warnung: Fehler beim Lesen von %s: %s"

#: mount/fstab.c:141 mount/fstab.c:164
#, c-format
msgid "warning: can't open %s: %s"
msgstr "Warnung: Konnte %s nicht öffnen: %s"

#: mount/fstab.c:145
#, c-format
msgid "mount: could not open %s - using %s instead\n"
msgstr "mount: Konnte %s nicht öffnen - benutze %s stattdessen\n"

#. linktargetfile does not exist (as a file)
#. and we cannot create it. Read-only filesystem?
#. Too many files open in the system?
#. Filesystem full?
#: mount/fstab.c:374
#, c-format
msgid "can't create lock file %s: %s (use -n flag to override)"
msgstr ""
"Konnte die Lock-Datei %s nicht anlegen: %s (benutzen Sie die -n Option, um "
"dies zu umgehen)"

#: mount/fstab.c:386
#, c-format
msgid "can't link lock file %s: %s (use -n flag to override)"
msgstr ""
"Konnte keinen Link für die Lock-Datei %s anlegen: %s (benutzen Sie die -n "
"Option, um dies zu umgehen)"

#: mount/fstab.c:398
#, c-format
msgid "can't open lock file %s: %s (use -n flag to override)"
msgstr ""
"Konnte die Lock-Datei %s nicht öffnen: %s (benutzen Sie die -n Option, um "
"dies zu umgehen)"

# This one should be merged with the next one by using
# error() instead of printf()
#: mount/fstab.c:413
#, c-format
msgid "Can't lock lock file %s: %s\n"
msgstr "Konnte die Lock-Datei %s nicht »locken«: %s\n"

# sperren
#: mount/fstab.c:426
#, c-format
msgid "can't lock lock file %s: %s"
msgstr "Konnte die Lock-Datei %s nicht »locken«: %s"

#: mount/fstab.c:428
msgid "timed out"
msgstr "Zeitüberschreitung"

#: mount/fstab.c:435
#, c-format
msgid ""
"Cannot create link %s\n"
"Perhaps there is a stale lock file?\n"
msgstr ""

#: mount/fstab.c:484 mount/fstab.c:520
#, c-format
msgid "cannot open %s (%s) - mtab not updated"
msgstr "Konnte %s nicht öffnen (%s) - mtab nicht aktualisiert"

#: mount/fstab.c:528
#, c-format
msgid "error writing %s: %s"
msgstr "Fehler beim Schreiben von %s: %s"

# "Modus" is the translation, that fileutils.po uses.
# I don't like it, but I haven't got a better one.
# Someone suggested "Zugriffsrechte", which I currently like
# better
# XXX - search for "Modus" and you'll find a similiar message
#: mount/fstab.c:536
#, c-format
msgid "error changing mode of %s: %s\n"
msgstr "Fehler beim Ändern der Zugriffsrechte von %s: %s\n"

#: mount/fstab.c:554
#, c-format
msgid "can't rename %s to %s: %s\n"
msgstr "Konnte %s nicht in %s umbenennen: %s\n"

#: mount/lomount.c:79
#, c-format
msgid "loop: can't open device %s: %s\n"
msgstr "loop: Konnte das Gerät %s nicht öffnen: %s\n"

#: mount/lomount.c:85
#, c-format
msgid "loop: can't get info on device %s: %s\n"
msgstr "loop: Konnte keine Informationen über das Gerät %s erhalten: %s\n"

#: mount/lomount.c:90
#, c-format
msgid "%s: [%04x]:%ld (%s) offset %d, %s encryption\n"
msgstr ""

# XXX - pretty dumb
#: mount/lomount.c:176
msgid "mount: could not find any device /dev/loop#"
msgstr "mount: Konnte kein Gerät /dev/loop# finden"

#: mount/lomount.c:180
msgid ""
"mount: Could not find any loop device.\n"
"       Maybe /dev/loop# has a wrong major number?"
msgstr ""
"mount: Konnte kein »loop«-Gerät finden.\n"
"       Vielleicht hat /dev/loop# eine falsche Major Nummer?"

#: mount/lomount.c:184
#, c-format
msgid ""
"mount: Could not find any loop device, and, according to %s,\n"
"       this kernel does not know about the loop device.\n"
"       (If so, then recompile or `insmod loop.o'.)"
msgstr ""
"mount: Konnte kein »loop«-Gerät finden. Laut %s unterstützt\n"
"       dieses Kernel keine »loop«-Geräte. (Wenn dies der Fall\n"
"       ist, dann sollten Sie das Kernel neu kompilieren oder\n"
"       »insmod loop.o« ausführen.)"

#: mount/lomount.c:190
msgid ""
"mount: Could not find any loop device. Maybe this kernel does not know\n"
"       about the loop device (then recompile or `insmod loop.o'), or\n"
"       maybe /dev/loop# has the wrong major number?"
msgstr ""
"mount: Konnte kein »loop«-Gerät finden. Vieleicht unterstützt\n"
"       dieses Kernel keine »loop«-Geräte (wenn dies der Fall\n"
"       ist, dann sollten Sie das Kernel neu kompilieren oder\n"
"       »insmod loop.o« ausführen) Oder vieleicht hat /dev/loop#\n"
"       eine falsche Major Nummer?"

#: mount/lomount.c:194
msgid "mount: could not find any free loop device"
msgstr "mount: Konnte kein freies »loop«-Gerät finden"

# Verschlüsselungstyp
#: mount/lomount.c:224
#, c-format
msgid "Unsupported encryption type %s\n"
msgstr "Die Verschlüsselungsmethode %s wird nicht unterstützt\n"

#: mount/lomount.c:238
msgid "Couldn't lock into memory, exiting.\n"
msgstr ""

#: mount/lomount.c:257
msgid "Init (up to 16 hex digits): "
msgstr ""

# "Ziffer" ?
#: mount/lomount.c:264
#, c-format
msgid "Non-hex digit '%c'.\n"
msgstr "Das Zeichen »%c« ist keine hexadezimale Ziffer.\n"

#: mount/lomount.c:271
#, c-format
msgid "Don't know how to get key for encryption system %d\n"
msgstr ""

#: mount/lomount.c:287
#, c-format
msgid "set_loop(%s,%s,%d): success\n"
msgstr "set_loop(%s, %s, %d): Erfolg\n"

# this is actually an open()...
#: mount/lomount.c:298
#, c-format
msgid "loop: can't delete device %s: %s\n"
msgstr "loop: Konnte das Gerät %s nicht löschen: %s\n"

#: mount/lomount.c:308
#, c-format
msgid "del_loop(%s): success\n"
msgstr "del_loop(%s): Erfolg\n"

#: mount/lomount.c:316
msgid "This mount was compiled without loop support. Please recompile.\n"
msgstr ""

# Setup
#: mount/lomount.c:353
#, c-format
msgid ""
"usage:\n"
"  %s loop_device                                      # give info\n"
"  %s -d loop_device                                   # delete\n"
"  %s [ -e encryption ] [ -o offset ] loop_device file # setup\n"
msgstr ""
"Aufruf:\n"
"  Informationen anzeigen:\n"
"    %s loop-Gerät\n"
"  Löschen:\n"
"    %s -d loop-Gerät\n"
"  Setup:\n"
"    %s [ -e Verschlüsselungsmethode ] [ -o Offset ] loop-Gerät Datei\n"

#: mount/lomount.c:371 mount/sundries.c:30 mount/sundries.c:45
msgid "not enough memory"
msgstr "Nicht genügend Speicher"

#: mount/lomount.c:442
msgid "No loop support was available at compile time. Please recompile.\n"
msgstr ""

#: mount/mntent.c:165
#, c-format
msgid "[mntent]: warning: no final newline at the end of %s\n"
msgstr ""
"[mntent]: Warnung: Am Ende der Datei %s fehlt ein abschließender newline.\n"

#: mount/mntent.c:216
#, c-format
msgid "[mntent]: line %d in %s is bad%s\n"
msgstr "[mntent]: Zeile %d in %s ist fehlerhaft%s\n"

#: mount/mntent.c:219
msgid "; rest of file ignored"
msgstr "; der Rest der Datei wurde ignoriert"

#: mount/mount.c:379
#, c-format
msgid "mount: according to mtab, %s is already mounted on %s"
msgstr "mount: Laut mtab ist %s schon auf %s gemountet"

#: mount/mount.c:383
#, c-format
msgid "mount: according to mtab, %s is mounted on %s"
msgstr "mount: Laut mtab ist %s auf %s gemountet"

#: mount/mount.c:404
#, c-format
msgid "mount: can't open %s for writing: %s"
msgstr "mount: Konnte %s nicht zum Schreiben öffnen: %s"

#: mount/mount.c:419 mount/mount.c:638
#, c-format
msgid "mount: error writing %s: %s"
msgstr "mount: Fehler beim Schreiben von %s: %s"

# "Modus"
#: mount/mount.c:426
#, c-format
msgid "mount: error changing mode of %s: %s"
msgstr "mount: Fehler beim Ändern der Zugriffsrechte von %s: %s"

#: mount/mount.c:472
#, c-format
msgid "%s looks like swapspace - not mounted"
msgstr ""

#: mount/mount.c:532
msgid "mount failed"
msgstr "mount ist fehlgeschlagen"

#: mount/mount.c:534
#, c-format
msgid "mount: only root can mount %s on %s"
msgstr "mount: Nur »root« kann %s auf %s mounten"

#: mount/mount.c:562
msgid "mount: loop device specified twice"
msgstr "mount: Das »loop«-Gerät wurde zweimal angegeben"

#: mount/mount.c:567
msgid "mount: type specified twice"
msgstr "mount: Der Typ wurde doppelt angegeben"

#: mount/mount.c:579
msgid "mount: skipping the setup of a loop device\n"
msgstr ""

#: mount/mount.c:588
#, c-format
msgid "mount: going to use the loop device %s\n"
msgstr "mount: werde das »loop«-Gerät %s verwenden\n"

#: mount/mount.c:592
msgid "mount: failed setting up loop device\n"
msgstr ""

#: mount/mount.c:596
msgid "mount: setup loop device successfully\n"
msgstr ""

#: mount/mount.c:633
#, c-format
msgid "mount: can't open %s: %s"
msgstr "mount: Konnte %s nicht öffnen: %s"

#: mount/mount.c:656
#, c-format
msgid "mount: cannot not open %s for setting speed"
msgstr "mount: Konnte %s nicht zum Setzen der Geschwindigkeit öffnen"

#: mount/mount.c:659
#, fuzzy, c-format
msgid "mount: cannot set speed: %s"
msgstr "mount: Konnte die Geschwindigkeit nicht setzen: %s"

#: mount/mount.c:720 mount/mount.c:1254
#, c-format
msgid "mount: cannot fork: %s"
msgstr "mount: Kann keinen neuen Prozess erzeugen: %s"

#: mount/mount.c:800
msgid "mount: this version was compiled without support for the type `nfs'"
msgstr ""
"mount: Diese Version wurde ohne Unterstützung für den Typ »nfs« kompiliert"

#: mount/mount.c:839
msgid "mount: failed with nfs mount version 4, trying 3..\n"
msgstr ""

#: mount/mount.c:850
msgid ""
"mount: I could not determine the filesystem type, and none was specified"
msgstr ""
"mount: Der Dateisystemtyp konnte nicht festgestellt werden\n"
"       und es wurde keiner angegeben"

#: mount/mount.c:853
msgid "mount: you must specify the filesystem type"
msgstr "mount: Sie müssen den Dateisystemtyp angeben"

#. should not happen
#: mount/mount.c:856
msgid "mount: mount failed"
msgstr "mount: mount ist fehlgeschlagen"

#: mount/mount.c:862 mount/mount.c:897
#, c-format
msgid "mount: mount point %s is not a directory"
msgstr "mount: Mountpunkt %s ist kein Verzeichnis"

# libc.po: "Keine Berechtigung"
#: mount/mount.c:864
msgid "mount: permission denied"
msgstr "mount: Zugriff verweigert"

#: mount/mount.c:866
msgid "mount: must be superuser to use mount"
msgstr ""

#. heuristic: if /proc/version exists, then probably proc is mounted
#. proc mounted?
#: mount/mount.c:870 mount/mount.c:874
#, c-format
msgid "mount: %s is busy"
msgstr "mount: %s wird gerade benutzt"

#. no
#. yes, don't mention it
#: mount/mount.c:876
msgid "mount: proc already mounted"
msgstr "mount: proc ist bereits gemountet"

#: mount/mount.c:878
#, c-format
msgid "mount: %s already mounted or %s busy"
msgstr "mount: %s ist bereits gemountet oder %s wird gerade benutzt"

#: mount/mount.c:884
#, c-format
msgid "mount: mount point %s does not exist"
msgstr "mount: Mountpunkt %s existiert nicht"

#: mount/mount.c:886
#, c-format
msgid "mount: mount point %s is a symbolic link to nowhere"
msgstr ""
"mount: Mountpunkt %s ist eine symbolische Verknüpfung,\n"
"       deren Ziel nicht existiert"

#: mount/mount.c:889
#, c-format
msgid "mount: special device %s does not exist"
msgstr "mount: Gerätedatei %s existiert nicht"

#: mount/mount.c:899
#, c-format
msgid ""
"mount: special device %s does not exist\n"
"       (a path prefix is not a directory)\n"
msgstr ""

#: mount/mount.c:912
#, c-format
msgid "mount: %s not mounted already, or bad option"
msgstr ""
"mount: %s ist noch nicht gemountet oder es wurden\n"
"       ungültige Optionen angegeben"

#: mount/mount.c:914
#, c-format
msgid ""
"mount: wrong fs type, bad option, bad superblock on %s,\n"
"       or too many mounted file systems"
msgstr ""
"mount: Falscher Dateisystemtyp, ungültige Optionen, der\n"
"       »Superblock« von %s ist beschädigt oder es sind\n"
"       zu viele Dateisysteme gemountet"

#: mount/mount.c:948
msgid "mount table full"
msgstr "Mounttabelle ist voll"

#: mount/mount.c:950
#, c-format
msgid "mount: %s: can't read superblock"
msgstr "mount: %s: Konnte den Superblock nicht lesen"

#: mount/mount.c:954
#, c-format
msgid "mount: %s: unknown device"
msgstr "umount: %s: unbekanntes Gerät"

#: mount/mount.c:959
#, c-format
msgid "mount: fs type %s not supported by kernel"
msgstr "mount: Der Dateisystemtyp »%s« wird nicht vom Kernel unterstützt"

#: mount/mount.c:971
#, c-format
msgid "mount: probably you meant %s"
msgstr "mount: Vielleicht meinten sie »%s«"

#: mount/mount.c:973
msgid "mount: maybe you meant iso9660 ?"
msgstr "mount: Vielleicht meinten Sie »iso9660«?"

#: mount/mount.c:976
#, c-format
msgid "mount: %s has wrong device number or fs type %s not supported"
msgstr ""
"mount: %s hat eine falsche Geräte-Nummer oder der\n"
"       Dateisystemtyp %s wird nicht unterstützt"

#. strange ...
#: mount/mount.c:982
#, c-format
msgid "mount: %s is not a block device, and stat fails?"
msgstr ""
"mount: %s ist kein blockorientiertes Gerät und »stat«\n"
"       schlug fehl?"

#: mount/mount.c:984
#, c-format
msgid ""
"mount: the kernel does not recognize %s as a block device\n"
"       (maybe `insmod driver'?)"
msgstr ""
"mount: Das Kernel erkennt %s nicht als blockorientiertes\n"
"       Gerät (Vielleicht hilft »insmod Treiber«?)"

# "versuchen"
#: mount/mount.c:987
#, c-format
msgid "mount: %s is not a block device (maybe try `-o loop'?)"
msgstr ""
"mount: %s ist kein blockorientiertes Gerät\n"
"       (Vielleicht probieren Sie »-o loop«?)"

#: mount/mount.c:990
#, c-format
msgid "mount: %s is not a block device"
msgstr "mount: %s ist kein blockorientiertes Gerät"

#: mount/mount.c:993
#, c-format
msgid "mount: %s is not a valid block device"
msgstr "mount: %s ist kein gültiges blockorientiertes Gerät"

#. pre-linux 1.1.38, 1.1.41 and later
#. linux 1.1.38 and later
#: mount/mount.c:996
msgid "block device "
msgstr "blockorientiertes Gerät "

#: mount/mount.c:998
#, c-format
msgid "mount: cannot mount %s%s read-only"
msgstr "mount: Konnte %s%s nicht im Nur-Lese-Modus mounten"

#: mount/mount.c:1002
#, c-format
msgid "mount: %s%s is write-protected but explicit `-w' flag given"
msgstr ""

# That sounds somehow dumb.
#: mount/mount.c:1018
#, c-format
msgid "mount: %s%s is write-protected, mounting read-only"
msgstr ""
"mount: %s%s ist schreibgeschützt, es wird im\n"
"       Nur-Lese-Modus gemountet"

#: mount/mount.c:1107
#, fuzzy, c-format
msgid "mount: going to mount %s by %s\n"
msgstr "mount: Ziehen Sie in Betracht %s mit Hilfe von »%s« zu mounten\n"

# I think, this should not be translated
#: mount/mount.c:1108
msgid "UUID"
msgstr "UUID"

# dito
#: mount/mount.c:1108
msgid "label"
msgstr "label"

#: mount/mount.c:1110 mount/mount.c:1489
msgid "mount: no such partition found"
msgstr "mount: Keine passende Partition gefunden"

#: mount/mount.c:1118
msgid "mount: no type was given - I'll assume nfs because of the colon\n"
msgstr ""
"mount: Es wurde kein Typ angegeben - Auf Grund des\n"
"       Doppelpunktes wird nfs angenommen\n"

#.
#. * Retry in the background.
#.
#: mount/mount.c:1134
#, c-format
msgid "mount: backgrounding \"%s\"\n"
msgstr "mount: »%s« wird im Hintergrund fortgesetzt\n"

# Not realy nice
#: mount/mount.c:1145
#, c-format
msgid "mount: giving up \"%s\"\n"
msgstr "mount: »%s« schlug fehl\n"

#: mount/mount.c:1205
#, c-format
msgid "mount: %s already mounted on %s\n"
msgstr "mount: %s ist bereits auf %s gemountet\n"

#: mount/mount.c:1323
msgid ""
"Usage: mount -V                 : print version\n"
"       mount -h                 : print this help\n"
"       mount                    : list mounted filesystems\n"
"       mount -l                 : idem, including volume labels\n"
"So far the informational part. Next the mounting.\n"
"The command is `mount [-t fstype] something somewhere'.\n"
"Details found in /etc/fstab may be omitted.\n"
"       mount -a                 : mount all stuff from /etc/fstab\n"
"       mount device             : mount device at the known place\n"
"       mount directory          : mount known device here\n"
"       mount -t type dev dir    : ordinary mount command\n"
"Note that one does not really mount a device, one mounts\n"
"a filesystem (of the given type) found on the device.\n"
"One can also mount an already visible directory tree elsewhere:\n"
"       mount --bind olddir newdir\n"
"A device can be given by name, say /dev/hda1 or /dev/cdrom,\n"
"or by label, using  -L label  or by uuid, using  -U uuid .\n"
"Other options: [-nfFrsvw] [-o options].\n"
"For many more details, say  man 8 mount .\n"
msgstr ""

#: mount/mount.c:1473
msgid "mount: only root can do that"
msgstr "mount: Nur »root« kann dies tun"

#: mount/mount.c:1478
#, c-format
msgid "mount: no %s found - creating it..\n"
msgstr "mount: %s nicht gefunden - Erzeuge sie...\n"

#: mount/mount.c:1491
#, c-format
msgid "mount: mounting %s\n"
msgstr "mount: Mounte %s\n"

#: mount/mount.c:1500
msgid "nothing was mounted"
msgstr ""

#: mount/mount.c:1515
#, c-format
msgid "mount: cannot find %s in %s"
msgstr "mount: Konnte %s nicht in %s finden"

#: mount/mount.c:1530
#, c-format
msgid "mount: can't find %s in %s or %s"
msgstr "mount: Konnte %s nicht in %s oder %s finden"

#: mount/mount_by_label.c:109
#, c-format
msgid ""
"mount: could not open %s, so UUID and LABEL conversion cannot be done.\n"
msgstr ""

#: mount/mount_by_label.c:211
msgid "mount: bad UUID"
msgstr "mount: ungültige UUID"

#: mount/mount_guess_fstype.c:393
#, c-format
msgid "mount: you didn't specify a filesystem type for %s\n"
msgstr "mount: Es wurde kein Dateisystemtyp für %s angegeben\n"

# Maybe:
# "       Es werden alle Dateisystemtypen ausprpbiert, die\n"
# "       in %s oder %s aufgelistet sind\n"
#: mount/mount_guess_fstype.c:396
#, c-format
msgid "       I will try all types mentioned in %s or %s\n"
msgstr ""
"       Werde alle Dateisystemtypen probieren, die in %s oder %s\n"
"       aufgelistet sind\n"

#: mount/mount_guess_fstype.c:399
msgid "       and it looks like this is swapspace\n"
msgstr ""

# Maybe: "       Es wird der Typ %s ausprobiert\n"
# or   : ... "versuchen"
#: mount/mount_guess_fstype.c:401
#, c-format
msgid "       I will try type %s\n"
msgstr "       Werde den Typ %s probieren\n"

#: mount/mount_guess_fstype.c:488
#, c-format
msgid "Trying %s\n"
msgstr "Versuche %s\n"

#: mount/nfsmount.c:231
msgid "mount: excessively long host:dir argument\n"
msgstr ""

#: mount/nfsmount.c:245
msgid "mount: warning: multiple hostnames not supported\n"
msgstr "mount: Mehrere Rechnernamen werden nicht unterstützt\n"

#: mount/nfsmount.c:250
msgid "mount: directory to mount not in host:dir format\n"
msgstr ""

#: mount/nfsmount.c:261 mount/nfsmount.c:516
#, c-format
msgid "mount: can't get address for %s\n"
msgstr "mount: Konnte die Adresse von %s nicht herausfinden\n"

#: mount/nfsmount.c:267
msgid "mount: got bad hp->h_length\n"
msgstr ""

#: mount/nfsmount.c:284
msgid "mount: excessively long option argument\n"
msgstr ""

#: mount/nfsmount.c:376
msgid "Warning: Unrecognized proto= option.\n"
msgstr "Warnung: unbekannte »proto=« Option.\n"

#: mount/nfsmount.c:383
msgid "Warning: Option namlen is not supported.\n"
msgstr "Warnung: Die Option »namlen« wird nicht unterstützt.\n"

#: mount/nfsmount.c:387
#, c-format
msgid "unknown nfs mount parameter: %s=%d\n"
msgstr "Unbekannter nfs-Mount-Parameter: %s=%d\n"

#: mount/nfsmount.c:421
msgid "Warning: option nolock is not supported.\n"
msgstr "Warnung: Die Option »nolock« wird nicht unterstützt.\n"

#: mount/nfsmount.c:426
#, c-format
msgid "unknown nfs mount option: %s%s\n"
msgstr "unbekannte nfs-Mount-Option: %s%s\n"

#: mount/nfsmount.c:522
msgid "mount: got bad hp->h_length?\n"
msgstr ""

#: mount/nfsmount.c:710
msgid "NFS over TCP is not supported.\n"
msgstr "NFS über TCP wird nicht unterstützt.\n"

#: mount/nfsmount.c:717
msgid "nfs socket"
msgstr ""

#: mount/nfsmount.c:721
msgid "nfs bindresvport"
msgstr ""

#: mount/nfsmount.c:735
msgid "nfs server reported service unavailable"
msgstr ""

#: mount/nfsmount.c:744
msgid "used portmapper to find NFS port\n"
msgstr ""

#: mount/nfsmount.c:748
#, c-format
msgid "using port %d for nfs deamon\n"
msgstr ""

#: mount/nfsmount.c:759
msgid "nfs connect"
msgstr ""

#: mount/nfsmount.c:846
#, c-format
msgid "unknown nfs status return value: %d"
msgstr ""

#: mount/sundries.c:55
msgid "bug in xstrndup call"
msgstr "Fehler im Aufruf von xstrndup (s==NULL)"

#: mount/swapon.c:51
#, c-format
msgid ""
"usage: %s [-hV]\n"
"       %s -a [-v]\n"
"       %s [-v] [-p priority] special ...\n"
"       %s [-s]\n"
msgstr ""
"Aufruf: %s [-hV]\n"
"        %s -a [-v]\n"
"        %s [-v] [-p Priorität] Spezialdatei ...\n"
"        %s [-s]\n"

# The first %s is swapon/swapoff
#: mount/swapon.c:88
#, c-format
msgid "%s on %s\n"
msgstr "%s für %s\n"

# stat
#: mount/swapon.c:93
#, c-format
msgid "swapon: cannot stat %s: %s\n"
msgstr "swapon: Konnte »stat« nicht auf %s anwenden: %s\n"

# "Modus"
#: mount/swapon.c:105
#, fuzzy, c-format
msgid "swapon: warning: %s has insecure permissions %04o, %04o suggested\n"
msgstr ""
"swapon: Warnung: Die Zugriffsrechte (%2$04o) von %1$s sind unsicher,\n"
"        0600 wird empfohlen\n"

# holes
#: mount/swapon.c:115
#, c-format
msgid "swapon: Skipping file %s - it appears to have holes.\n"
msgstr "swapon: Überspringe die Datei %s - sie scheint »holes« zu enthalten.\n"

#: mount/swapon.c:222
#, c-format
msgid "%s: cannot open %s: %s\n"
msgstr "%s: Konnte %s nicht öffnen: %s\n"

# XXX - "einkompiliert"
#: mount/umount.c:75
msgid "umount: compiled without support for -f\n"
msgstr "umount: Die Unterstützung für -f wurde nicht einkompiliert\n"

#: mount/umount.c:148
#, c-format
msgid "host: %s, directory: %s\n"
msgstr "Rechner: %s, Verzeichnis: %s\n"

#: mount/umount.c:168
#, c-format
msgid "umount: can't get address for %s\n"
msgstr "umount: Konnte die Adresse von %s nicht herausfinden\n"

#: mount/umount.c:173
msgid "umount: got bad hostp->h_length\n"
msgstr ""

#: mount/umount.c:221
#, c-format
msgid "umount: %s: invalid block device"
msgstr "umount: %s: kein gültiges blockorientiertes Gerät"

#: mount/umount.c:223
#, c-format
msgid "umount: %s: not mounted"
msgstr "umount: %s ist nicht gemountet"

#: mount/umount.c:225
#, c-format
msgid "umount: %s: can't write superblock"
msgstr "umount: %s: Konnte den »Superblock« nicht schreiben"

# XXX - I did have a better one for busy
# libc.po:
# "Device or resource busy"
# "Das Gerät oder die Ressource ist belegt"
#. Let us hope fstab has a line "proc /proc ..."
#. and not "none /proc ..."
#: mount/umount.c:229
#, c-format
msgid "umount: %s: device is busy"
msgstr "umount: %s: Das Gerät wird momenten noch benutzt"

#: mount/umount.c:231
#, c-format
msgid "umount: %s: not found"
msgstr "umount: %s: Nicht gefunden"

#: mount/umount.c:233
#, c-format
msgid "umount: %s: must be superuser to umount"
msgstr ""

#: mount/umount.c:235
#, c-format
msgid "umount: %s: block devices not permitted on fs"
msgstr ""

#: mount/umount.c:237
#, c-format
msgid "umount: %s: %s"
msgstr "umount: %s: %s"

#: mount/umount.c:284
#, fuzzy
msgid "no umount2, trying umount...\n"
msgstr "kein umount2, versuche umount...\n"

#: mount/umount.c:300
#, fuzzy, c-format
msgid "could not umount %s - trying %s instead\n"
msgstr "konnte %s nicht umounten - versuche %s stattdessen\n"

# XXX
#: mount/umount.c:318
#, fuzzy, c-format
msgid "umount: %s busy - remounted read-only\n"
msgstr "umount: %s wird momentan noch benutzt - remounted read-only\n"

#: mount/umount.c:328
#, c-format
msgid "umount: could not remount %s read-only\n"
msgstr ""

#: mount/umount.c:337
#, c-format
msgid "%s umounted\n"
msgstr ""

#: mount/umount.c:424
msgid "umount: cannot find list of filesystems to unmount"
msgstr "umount: Kann die Liste der Dateisysteme zum unmounten nicht finden"

#: mount/umount.c:453
msgid ""
"Usage: umount [-hV]\n"
"       umount -a [-f] [-r] [-n] [-v] [-t vfstypes]\n"
"       umount [-f] [-r] [-n] [-v] special | node...\n"
msgstr ""
"Aufruf: umount [-hV]\n"
"        umoumt -a [-f] [-r] [-n] [-v] [-t VFS-Typen]\n"
"        umount [-f] [-r] [-n] [-v] Spezialdatei | Verzeichnis ...\n"

#: mount/umount.c:510
#, c-format
msgid "Trying to umount %s\n"
msgstr "Versuche %s zu umounten\n"

#: mount/umount.c:514
#, c-format
msgid "Could not find %s in mtab\n"
msgstr "Konnte %s nicht in »mtab« finden\n"

#: mount/umount.c:518
#, c-format
msgid "umount: %s is not mounted (according to mtab)"
msgstr "umount: %s ist laut »mtab« nicht gemountet"

#: mount/umount.c:520
#, c-format
msgid "umount: it seems %s is mounted multiple times"
msgstr "umount: %s scheint mehrfach gemountet zu sein"

#: mount/umount.c:532
#, c-format
msgid "umount: %s is not in the fstab (and you are not root)"
msgstr "umount: fstab enthält %s nicht (Nur root kann es unmounten)"

#: mount/umount.c:535
#, c-format
msgid "umount: %s mount disagrees with the fstab"
msgstr ""

#: mount/umount.c:556
#, c-format
msgid "umount: only root can unmount %s from %s"
msgstr "umount: Nur »root« kann %s von %s unmounten"

#: mount/umount.c:567
#, c-format
msgid "umount: only %s can unmount %s from %s"
msgstr "umount: Nur %s kann %s von %s unmounten"

#: mount/umount.c:639
msgid "umount: only root can do that"
msgstr "umount: Nur »root« kann dies tun"

#: sys-utils/ctrlaltdel.c:27
msgid "You must be root to set the Ctrl-Alt-Del behaviour.\n"
msgstr "Nur root kann das Verhalten bei Strg-Alt-Entf ändern.\n"

#: sys-utils/ctrlaltdel.c:42
msgid "Usage: ctrlaltdel hard|soft\n"
msgstr "Aufruf: ctrlaltdel hard|soft\n"

#: sys-utils/cytune.c:120
#, c-format
msgid ""
"File %s, For threshold value %lu, Maximum characters in fifo were %d,\n"
"and the maximum transfer rate in characters/second was %f\n"
msgstr ""

#: sys-utils/cytune.c:131
#, c-format
msgid ""
"File %s, For threshold value %lu and timrout value %lu, Maximum characters "
"in fifo were %d,\n"
"and the maximum transfer rate in characters/second was %f\n"
msgstr ""

#: sys-utils/cytune.c:196
#, c-format
msgid "Invalid interval value: %s\n"
msgstr ""

#: sys-utils/cytune.c:204
#, c-format
msgid "Invalid set value: %s\n"
msgstr ""

#: sys-utils/cytune.c:212
#, c-format
msgid "Invalid default value: %s\n"
msgstr ""

#: sys-utils/cytune.c:220
#, c-format
msgid "Invalid set time value: %s\n"
msgstr ""

#: sys-utils/cytune.c:228
#, c-format
msgid "Invalid default time value: %s\n"
msgstr ""

#: sys-utils/cytune.c:245
#, c-format
msgid ""
"Usage: %s [-q [-i interval]] ([-s value]|[-S value]) ([-t value]|[-T value]) "
"[-g|-G] file [file...]\n"
msgstr ""

#: sys-utils/cytune.c:257 sys-utils/cytune.c:276 sys-utils/cytune.c:296
#: sys-utils/cytune.c:346
#, c-format
msgid "Can't open %s: %s\n"
msgstr "Konnte %s nicht öffnen: %s\n"

#: sys-utils/cytune.c:264
#, c-format
msgid "Can't set %s to threshold %d: %s\n"
msgstr ""

#: sys-utils/cytune.c:283
#, c-format
msgid "Can't set %s to time threshold %d: %s\n"
msgstr ""

#: sys-utils/cytune.c:301 sys-utils/cytune.c:358 sys-utils/cytune.c:389
#, c-format
msgid "Can't get threshold for %s: %s\n"
msgstr ""

#: sys-utils/cytune.c:307 sys-utils/cytune.c:364 sys-utils/cytune.c:395
#, c-format
msgid "Can't get timeout for %s: %s\n"
msgstr ""

#: sys-utils/cytune.c:313
#, c-format
msgid "%s: %ld current threshold and %ld current timeout\n"
msgstr ""

#: sys-utils/cytune.c:316
#, c-format
msgid "%s: %ld default threshold and %ld default timeout\n"
msgstr ""

#: sys-utils/cytune.c:334
msgid "Can't set signal handler"
msgstr ""

#: sys-utils/cytune.c:338 sys-utils/cytune.c:373
msgid "gettimeofday failed"
msgstr ""

#: sys-utils/cytune.c:351 sys-utils/cytune.c:383
#, c-format
msgid "Can't issue CYGETMON on %s: %s\n"
msgstr ""

#: sys-utils/cytune.c:425
#, c-format
msgid ""
"%s: %lu ints, %lu/%lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"
msgstr ""

#: sys-utils/cytune.c:431
#, c-format
msgid "   %f int/sec; %f rec, %f send (char/sec)\n"
msgstr ""

#: sys-utils/cytune.c:436
#, c-format
msgid ""
"%s: %lu ints, %lu chars; fifo: %lu thresh, %lu tmout, %lu max, %lu now\n"
msgstr ""

#: sys-utils/cytune.c:442
#, c-format
msgid "   %f int/sec; %f rec (char/sec)\n"
msgstr ""

# "Level"
#: sys-utils/dmesg.c:37
#, c-format
msgid "Usage: %s [-c] [-n level] [-s bufsize]\n"
msgstr "Aufruf: %s [-c] [-n Level] [-s Puffergröße]\n"

#: sys-utils/ipcrm.c:59
#, c-format
msgid "invalid id: %s\n"
msgstr ""

#: sys-utils/ipcrm.c:77
#, c-format
msgid "cannot remove id %s (%s)\n"
msgstr ""

#: sys-utils/ipcrm.c:91
#, fuzzy, c-format
msgid "usage: %s {shm | msg | sem} id ...\n"
msgstr "Aufruf: %s {shm | msg | sem} Id ...\n"

#: sys-utils/ipcrm.c:124
#, c-format
msgid "unknown resource type: %s\n"
msgstr ""

#: sys-utils/ipcrm.c:128
msgid "resource(s) deleted\n"
msgstr ""

#: sys-utils/ipcs.c:122
#, c-format
msgid "usage : %s -asmq -tclup \n"
msgstr "Aufruf: %s -asmq -tclup\n"

#: sys-utils/ipcs.c:123
#, c-format
msgid "\t%s [-s -m -q] -i id\n"
msgstr "\t%s [-s -m -q] -i Id\n"

#: sys-utils/ipcs.c:124
#, c-format
msgid "\t%s -h for help.\n"
msgstr "\t%s -h für weitere Informationen.\n"

#: sys-utils/ipcs.c:130
#, c-format
msgid ""
"%s provides information on ipc facilities for which you have read access.\n"
msgstr ""

#: sys-utils/ipcs.c:132
msgid ""
"Resource Specification:\n"
"\t-m : shared_mem\n"
"\t-q : messages\n"
msgstr ""

#: sys-utils/ipcs.c:133
msgid ""
"\t-s : semaphores\n"
"\t-a : all (default)\n"
msgstr ""

#: sys-utils/ipcs.c:134
msgid ""
"Output Format:\n"
"\t-t : time\n"
"\t-p : pid\n"
"\t-c : creator\n"
msgstr ""

#: sys-utils/ipcs.c:135
msgid ""
"\t-l : limits\n"
"\t-u : summary\n"
msgstr ""

#: sys-utils/ipcs.c:136
msgid "-i id [-s -q -m] : details on resource identified by id\n"
msgstr ""

#: sys-utils/ipcs.c:268
msgid "kernel not configured for shared memory\n"
msgstr ""

#: sys-utils/ipcs.c:274
msgid "------ Shared Memory Limits --------\n"
msgstr ""

#. glibc 2.1.3 and all earlier libc's have ints as fields
#. of struct shminfo; glibc 2.1.91 has unsigned long; ach
#: sys-utils/ipcs.c:279
#, c-format
msgid "max number of segments = %ld\n"
msgstr "Maximale Anzahl der Segmente = %ld\n"

#: sys-utils/ipcs.c:281
#, c-format
msgid "max seg size (kbytes) = %ld\n"
msgstr "Maximale Segmentgröße (kB) = %ld\n"

#: sys-utils/ipcs.c:283
#, c-format
msgid "max total shared memory (kbytes) = %ld\n"
msgstr ""

#: sys-utils/ipcs.c:285
#, fuzzy, c-format
msgid "min seg size (bytes) = %ld\n"
msgstr "Minimale Segmentgröße (Bytes) = %ld\n"

#: sys-utils/ipcs.c:290
msgid "------ Shared Memory Status --------\n"
msgstr ""

#: sys-utils/ipcs.c:291
#, c-format
msgid "segments allocated %d\n"
msgstr ""

#: sys-utils/ipcs.c:292
#, c-format
msgid "pages allocated %ld\n"
msgstr ""

#: sys-utils/ipcs.c:293
#, c-format
msgid "pages resident  %ld\n"
msgstr ""

#: sys-utils/ipcs.c:294
#, c-format
msgid "pages swapped   %ld\n"
msgstr ""

#: sys-utils/ipcs.c:295
#, c-format
msgid "Swap performance: %ld attempts\t %ld successes\n"
msgstr ""

#: sys-utils/ipcs.c:300
msgid "------ Shared Memory Segment Creators/Owners --------\n"
msgstr ""

#: sys-utils/ipcs.c:301 sys-utils/ipcs.c:418 sys-utils/ipcs.c:518
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s %-10s %-10s\n"
msgstr "%-10s%-10s%-10s%-10s%-10s%-10s\n"

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:308 sys-utils/ipcs.c:315
#: sys-utils/ipcs.c:321 sys-utils/ipcs.c:425
msgid "shmid"
msgstr ""

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:321 sys-utils/ipcs.c:419
#: sys-utils/ipcs.c:434 sys-utils/ipcs.c:519 sys-utils/ipcs.c:537
#, fuzzy
msgid "perms"
msgstr "Rechte"

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:419 sys-utils/ipcs.c:519
msgid "cuid"
msgstr "cuid"

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:419 sys-utils/ipcs.c:519
msgid "cgid"
msgstr "cgid"

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:419 sys-utils/ipcs.c:519
msgid "uid"
msgstr "uid"

#: sys-utils/ipcs.c:302 sys-utils/ipcs.c:519
msgid "gid"
msgstr "gid"

#: sys-utils/ipcs.c:306
msgid "------ Shared Memory Attach/Detach/Change Times --------\n"
msgstr ""

#: sys-utils/ipcs.c:307
#, fuzzy, c-format
msgid "%-10s %-10s %-20s %-20s %-20s\n"
msgstr "%-10s%-10s  %-20s%-20s%-20s\n"

#: sys-utils/ipcs.c:308 sys-utils/ipcs.c:315 sys-utils/ipcs.c:321
#: sys-utils/ipcs.c:425 sys-utils/ipcs.c:434 sys-utils/ipcs.c:525
#: sys-utils/ipcs.c:531 sys-utils/ipcs.c:537
#, fuzzy
msgid "owner"
msgstr "Besitzer"

#: sys-utils/ipcs.c:308
msgid "attached"
msgstr ""

#: sys-utils/ipcs.c:308
msgid "detached"
msgstr ""

#: sys-utils/ipcs.c:309
msgid "changed"
msgstr ""

#: sys-utils/ipcs.c:313
msgid "------ Shared Memory Creator/Last-op --------\n"
msgstr ""

#: sys-utils/ipcs.c:314 sys-utils/ipcs.c:530
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s\n"
msgstr "%-10s%-10s%-10s%-10s\n"

#: sys-utils/ipcs.c:315
msgid "cpid"
msgstr ""

#: sys-utils/ipcs.c:315
msgid "lpid"
msgstr ""

#: sys-utils/ipcs.c:319
msgid "------ Shared Memory Segments --------\n"
msgstr ""

#: sys-utils/ipcs.c:320
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s %-10s %-10s %-12s\n"
msgstr "%-10s%-10s%-10s%-10s%-10s%-10s%-12s\n"

#: sys-utils/ipcs.c:321 sys-utils/ipcs.c:434 sys-utils/ipcs.c:537
msgid "key"
msgstr ""

#: sys-utils/ipcs.c:321
msgid "bytes"
msgstr "Bytes"

#: sys-utils/ipcs.c:322
msgid "nattch"
msgstr ""

#: sys-utils/ipcs.c:322 sys-utils/ipcs.c:435
msgid "status"
msgstr "Status"

#: sys-utils/ipcs.c:343 sys-utils/ipcs.c:345 sys-utils/ipcs.c:347
#: sys-utils/ipcs.c:456 sys-utils/ipcs.c:458 sys-utils/ipcs.c:558
#: sys-utils/ipcs.c:560 sys-utils/ipcs.c:562 sys-utils/ipcs.c:615
#: sys-utils/ipcs.c:617 sys-utils/ipcs.c:646 sys-utils/ipcs.c:648
#: sys-utils/ipcs.c:650 sys-utils/ipcs.c:674
msgid "Not set"
msgstr "Nicht gesetzt"

#: sys-utils/ipcs.c:372
msgid "dest"
msgstr ""

#: sys-utils/ipcs.c:373
msgid "locked"
msgstr ""

#: sys-utils/ipcs.c:393
msgid "kernel not configured for semaphores\n"
msgstr ""

#: sys-utils/ipcs.c:399
msgid "------ Semaphore Limits --------\n"
msgstr ""

#: sys-utils/ipcs.c:403
#, c-format
msgid "max number of arrays = %d\n"
msgstr ""

#: sys-utils/ipcs.c:404
#, c-format
msgid "max semaphores per array = %d\n"
msgstr ""

#: sys-utils/ipcs.c:405
#, c-format
msgid "max semaphores system wide = %d\n"
msgstr ""

#: sys-utils/ipcs.c:406
#, c-format
msgid "max ops per semop call = %d\n"
msgstr ""

#: sys-utils/ipcs.c:407
#, c-format
msgid "semaphore max value = %d\n"
msgstr ""

#: sys-utils/ipcs.c:411
msgid "------ Semaphore Status --------\n"
msgstr ""

#: sys-utils/ipcs.c:412
#, c-format
msgid "used arrays = %d\n"
msgstr ""

#: sys-utils/ipcs.c:413
#, c-format
msgid "allocated semaphores = %d\n"
msgstr ""

#: sys-utils/ipcs.c:417
msgid "------ Semaphore Arrays Creators/Owners --------\n"
msgstr ""

#: sys-utils/ipcs.c:419 sys-utils/ipcs.c:434
msgid "semid"
msgstr ""

#: sys-utils/ipcs.c:423
msgid "------ Shared Memory Operation/Change Times --------\n"
msgstr ""

#: sys-utils/ipcs.c:424
#, fuzzy, c-format
msgid "%-8s %-10s %-26.24s %-26.24s\n"
msgstr "%-8s%-10s  %-26.24s %-26.24s\n"

#: sys-utils/ipcs.c:425
msgid "last-op"
msgstr ""

#: sys-utils/ipcs.c:425
msgid "last-changed"
msgstr ""

#: sys-utils/ipcs.c:432
msgid "------ Semaphore Arrays --------\n"
msgstr ""

#: sys-utils/ipcs.c:433
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s %-10s %-12s\n"
msgstr "%-10s%-10s%-10s%-10s%-10s%-10s\n"

#: sys-utils/ipcs.c:435
msgid "nsems"
msgstr ""

#: sys-utils/ipcs.c:495
msgid "kernel not configured for message queues\n"
msgstr ""

#: sys-utils/ipcs.c:503
msgid "------ Messages: Limits --------\n"
msgstr ""

#: sys-utils/ipcs.c:504
#, c-format
msgid "max queues system wide = %d\n"
msgstr ""

#: sys-utils/ipcs.c:505
#, c-format
msgid "max size of message (bytes) = %d\n"
msgstr ""

#: sys-utils/ipcs.c:506
#, c-format
msgid "default max size of queue (bytes) = %d\n"
msgstr ""

#: sys-utils/ipcs.c:510
msgid "------ Messages: Status --------\n"
msgstr ""

#: sys-utils/ipcs.c:511
#, c-format
msgid "allocated queues = %d\n"
msgstr ""

#: sys-utils/ipcs.c:512
#, c-format
msgid "used headers = %d\n"
msgstr ""

#: sys-utils/ipcs.c:513
#, c-format
msgid "used space = %d bytes\n"
msgstr ""

#: sys-utils/ipcs.c:517
msgid "------ Message Queues: Creators/Owners --------\n"
msgstr ""

#: sys-utils/ipcs.c:519 sys-utils/ipcs.c:525 sys-utils/ipcs.c:531
#: sys-utils/ipcs.c:537
msgid "msqid"
msgstr ""

#: sys-utils/ipcs.c:523
msgid "------ Message Queues Send/Recv/Change Times --------\n"
msgstr ""

#: sys-utils/ipcs.c:524
#, fuzzy, c-format
msgid "%-8s %-10s %-20s %-20s %-20s\n"
msgstr "%-8s%-10s  %-20s%-20s%-20s\n"

#: sys-utils/ipcs.c:525
msgid "send"
msgstr ""

#: sys-utils/ipcs.c:525
msgid "recv"
msgstr ""

#: sys-utils/ipcs.c:525
msgid "change"
msgstr ""

#: sys-utils/ipcs.c:529
msgid "------ Message Queues PIDs --------\n"
msgstr ""

#: sys-utils/ipcs.c:531
msgid "lspid"
msgstr ""

#: sys-utils/ipcs.c:531
msgid "lrpid"
msgstr ""

#: sys-utils/ipcs.c:535
msgid "------ Message Queues --------\n"
msgstr ""

#: sys-utils/ipcs.c:536
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s %-12s %-12s\n"
msgstr "%-10s%-10s%-10s%-10s%-10s%-10s\n"

#: sys-utils/ipcs.c:538
msgid "used-bytes"
msgstr ""

#: sys-utils/ipcs.c:538
msgid "messages"
msgstr ""

#: sys-utils/ipcs.c:606
#, c-format
msgid ""
"\n"
"Shared memory Segment shmid=%d\n"
msgstr ""

# similiar message below.
#: sys-utils/ipcs.c:607
#, c-format
msgid "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\n"
msgstr ""

# similiar message below.
#: sys-utils/ipcs.c:609
#, c-format
msgid "mode=%#o\taccess_perms=%#o\n"
msgstr ""

#: sys-utils/ipcs.c:611
#, c-format
msgid "bytes=%d\tlpid=%d\tcpid=%d\tnattch=%ld\n"
msgstr ""

#: sys-utils/ipcs.c:614
#, c-format
msgid "att_time=%-26.24s\n"
msgstr ""

#: sys-utils/ipcs.c:616
#, fuzzy, c-format
msgid "det_time=%-26.24s\n"
msgstr "Änderungszeit = %s"

#: sys-utils/ipcs.c:618 sys-utils/ipcs.c:649
#, fuzzy, c-format
msgid "change_time=%-26.24s\n"
msgstr "Änderungszeit = %s"

#: sys-utils/ipcs.c:633
#, c-format
msgid ""
"\n"
"Message Queue msqid=%d\n"
msgstr ""

#: sys-utils/ipcs.c:634
#, c-format
msgid "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\tmode=%#o\n"
msgstr ""

#: sys-utils/ipcs.c:636
#, c-format
msgid "cbytes=%ld\tqbytes=%ld\tqnum=%ld\tlspid=%d\tlrpid=%d\n"
msgstr ""

#: sys-utils/ipcs.c:645
#, fuzzy, c-format
msgid "send_time=%-26.24s\n"
msgstr "Änderungszeit = %s"

#: sys-utils/ipcs.c:647
#, fuzzy, c-format
msgid "rcv_time=%-26.24s\n"
msgstr "ctime = %s"

#: sys-utils/ipcs.c:667
#, c-format
msgid ""
"\n"
"Semaphore Array semid=%d\n"
msgstr ""

#: sys-utils/ipcs.c:668
#, c-format
msgid "uid=%d\t gid=%d\t cuid=%d\t cgid=%d\n"
msgstr "uid=%d\t gid=%d\t cuid=%d\t cgid=%d\n"

#: sys-utils/ipcs.c:670
#, c-format
msgid "mode=%#o, access_perms=%#o\n"
msgstr ""

#: sys-utils/ipcs.c:672
#, c-format
msgid "nsems = %ld\n"
msgstr "nsems = %ld\n"

#: sys-utils/ipcs.c:673
#, fuzzy, c-format
msgid "otime = %-26.24s\n"
msgstr "otime = %s"

#: sys-utils/ipcs.c:675
#, fuzzy, c-format
msgid "ctime = %-26.24s\n"
msgstr "ctime = %s"

#: sys-utils/ipcs.c:677
#, fuzzy, c-format
msgid "%-10s %-10s %-10s %-10s %-10s\n"
msgstr "%-10s%-10s%-10s%-10s%-10s\n"

#: sys-utils/ipcs.c:678
msgid "semnum"
msgstr ""

#: sys-utils/ipcs.c:678
#, fuzzy
msgid "value"
msgstr "Wert"

#: sys-utils/ipcs.c:678
msgid "ncount"
msgstr ""

#: sys-utils/ipcs.c:678
msgid "zcount"
msgstr ""

#: sys-utils/ipcs.c:678
msgid "pid"
msgstr "Pid"

#: sys-utils/rdev.c:69
msgid "usage: rdev [ -rv ] [ -o OFFSET ] [ IMAGE [ VALUE [ OFFSET ] ] ]"
msgstr ""

# Oh well, "ROOT-Gerät" sounds sooo stupid
#: sys-utils/rdev.c:70
#, fuzzy
msgid ""
"  rdev /dev/fd0  (or rdev /linux, etc.) displays the current ROOT device"
msgstr ""
"  rdev /dev/fd0  (oder rdev /linux, etc.) zeigt das aktuelle ROOT-Gerät an"

#: sys-utils/rdev.c:71
msgid "  rdev /dev/fd0 /dev/hda2         sets ROOT to /dev/hda2"
msgstr ""

#: sys-utils/rdev.c:72
msgid "  rdev -R /dev/fd0 1              set the ROOTFLAGS (readonly status)"
msgstr ""

#: sys-utils/rdev.c:73
msgid "  rdev -r /dev/fd0 627            set the RAMDISK size"
msgstr ""

#: sys-utils/rdev.c:74
msgid "  rdev -v /dev/fd0 1              set the bootup VIDEOMODE"
msgstr ""

#: sys-utils/rdev.c:75
msgid "  rdev -o N ...                   use the byte offset N"
msgstr ""

#: sys-utils/rdev.c:76
#, fuzzy
msgid "  rootflags ...                   same as rdev -R"
msgstr "  rootflags ...                   Das gleiche wie rdev -R"

#: sys-utils/rdev.c:77
#, fuzzy
msgid "  ramsize ...                     same as rdev -r"
msgstr "  ramsize ...                     Das gleiche wie rdev -r"

#: sys-utils/rdev.c:78
#, fuzzy
msgid "  vidmode ...                     same as rdev -v"
msgstr "  vidmode ...                     Das gleiche wie rdev -v"

#: sys-utils/rdev.c:79
msgid ""
"Note: video modes are: -3=Ask, -2=Extended, -1=NormalVga, 1=key1, 2=key2,..."
msgstr ""

#: sys-utils/rdev.c:80
msgid "      use -R 1 to mount root readonly, -R 0 for read/write."
msgstr ""

#: sys-utils/rdev.c:247
msgid "missing comma"
msgstr ""

#: sys-utils/readprofile.c:54
#, c-format
msgid ""
"%s: Usage: \"%s [options]\n"
"\t -m <mapfile>  (default = \"%s\")\n"
"\t -p <pro-file> (default = \"%s\")\n"
"\t -M <mult>     set the profiling multiplier to <mult>\n"
"\t -i            print only info about the sampling step\n"
"\t -v            print verbose data\n"
"\t -a            print all symbols, even if count is 0\n"
"\t -r            reset all the counters (root only)\n"
"\t -V            print version and exit\n"
msgstr ""

#: sys-utils/readprofile.c:76
#, fuzzy
msgid "out of memory"
msgstr "Speicher ist alle\n"

#: sys-utils/readprofile.c:136
#, c-format
msgid "%s Version %s\n"
msgstr "%s Version %s\n"

#: sys-utils/readprofile.c:195
#, c-format
msgid "Sampling_step: %i\n"
msgstr ""

#: sys-utils/readprofile.c:208 sys-utils/readprofile.c:231
#, c-format
msgid "%s: %s(%i): wrong map line\n"
msgstr ""

#: sys-utils/readprofile.c:219
#, c-format
msgid "%s: can't find \"_stext\" in %s\n"
msgstr "%s: Konnte \"_stext\" nicht in %s finden\n"

#: sys-utils/readprofile.c:242
#, c-format
msgid "%s: profile address out of range. Wrong map file?\n"
msgstr ""

#: sys-utils/readprofile.c:268
msgid "total"
msgstr ""

#: sys-utils/renice.c:68
msgid ""
"usage: renice priority [ [ -p ] pids ] [ [ -g ] pgrps ] [ [ -u ] users ]\n"
msgstr ""
"Aufruf: renice Priorität [[-p] PIDs ] [[-g] PGRPs ] [[-u] Benutzernamen ]\n"

#: sys-utils/renice.c:97
#, c-format
msgid "renice: %s: unknown user\n"
msgstr "renice: Unbekannter Benutzer: %s\n"

#: sys-utils/renice.c:105
#, c-format
msgid "renice: %s: bad value\n"
msgstr "renice: Ungültiger Wert: %s\n"

#: sys-utils/renice.c:123 sys-utils/renice.c:135
msgid "getpriority"
msgstr "getpriority"

#: sys-utils/renice.c:128
msgid "setpriority"
msgstr "setpriority"

#: sys-utils/renice.c:139
#, c-format
msgid "%d: old priority %d, new priority %d\n"
msgstr "%d: Alte Priorität: %d, neue Priorität: %d\n"

#: sys-utils/setsid.c:26
#, c-format
msgid "usage: %s program [arg ...]\n"
msgstr "Aufruf: %s Programm [Argument ...]\n"

#: sys-utils/tunelp.c:75
#, c-format
msgid ""
"Usage: %s <device> [ -i <IRQ> | -t <TIME> | -c <CHARS> | -w <WAIT> | \n"
"          -a [on|off] | -o [on|off] | -C [on|off] | -q [on|off] | -s | \n"
"          -T [on|off] ]\n"
msgstr ""

#: sys-utils/tunelp.c:91
msgid "malloc error"
msgstr ""

#: sys-utils/tunelp.c:103
#, c-format
msgid "%s: bad value\n"
msgstr "%s: Ungültiger Wert\n"

#: sys-utils/tunelp.c:242
#, c-format
msgid "%s: %s not an lp device.\n"
msgstr "%s: %s ist kein lp-Gerät.\n"

#: sys-utils/tunelp.c:263
#, c-format
msgid "%s status is %d"
msgstr "Der Status von %s ist 0x%x"

#: sys-utils/tunelp.c:264
msgid ", busy"
msgstr ", belegt"

#: sys-utils/tunelp.c:265
msgid ", ready"
msgstr ", bereit"

#: sys-utils/tunelp.c:266
msgid ", out of paper"
msgstr ", kein Papier"

# tl: "betriebsbereit"
#: sys-utils/tunelp.c:267
msgid ", on-line"
msgstr ", on-line"

#: sys-utils/tunelp.c:268
msgid ", error"
msgstr ", Fehler"

#: sys-utils/tunelp.c:285
msgid "LPGETIRQ error"
msgstr "»LPGETIRQ« Fehler"

#: sys-utils/tunelp.c:291
#, c-format
msgid "%s using IRQ %d\n"
msgstr "%s benutzt IRQ %d\n"

#: sys-utils/tunelp.c:293
#, c-format
msgid "%s using polling\n"
msgstr ""

#: text-utils/col.c:155
#, fuzzy, c-format
msgid "col: bad -l argument %s.\n"
msgstr "col: Ungültiges Argument für »-l«-Option: %s.\n"

#: text-utils/col.c:537
msgid "usage: col [-bfpx] [-l nline]\n"
msgstr "Aufruf: col [-bfpx] [-l AnzahlZeilen]\n"

#: text-utils/col.c:543
msgid "col: write error.\n"
msgstr "col: Fehler beim Schreiben.\n"

# %s can be one of the two following texts.
#: text-utils/col.c:550
#, c-format
msgid "col: warning: can't back up %s.\n"
msgstr ""

#: text-utils/col.c:551
msgid "past first line"
msgstr ""

#: text-utils/col.c:551
msgid "-- line already flushed"
msgstr ""

#: text-utils/colcrt.c:97
#, c-format
msgid "usage: %s [ - ] [ -2 ] [ file ... ]\n"
msgstr "Aufruf: %s [ - ] [ -2 ] [ Datei ... ]\n"

#: text-utils/column.c:300
msgid "line too long"
msgstr "Zeile ist zu lang"

#: text-utils/column.c:377
msgid "usage: column [-tx] [-c columns] [file ...]\n"
msgstr "Aufruf: column [-tx] [-c Spalten] [Datei ...]\n"

#: text-utils/hexsyntax.c:80
msgid "hexdump: bad length value.\n"
msgstr ""

#: text-utils/hexsyntax.c:91
msgid "hexdump: bad skip value.\n"
msgstr ""

#: text-utils/hexsyntax.c:129
msgid ""
"hexdump: [-bcdovx] [-e fmt] [-f fmt_file] [-n length] [-s skip] [file ...]\n"
msgstr ""

#: text-utils/more.c:263
#, c-format
msgid "usage: %s [-dflpcsu] [+linenum | +/pattern] name1 name2 ...\n"
msgstr ""
"Aufruf: %s [-dflpcsu] [+Zeilennummer | +/Muster] Dateiname1 Dateiname2 ...\n"

#: text-utils/more.c:521
#, c-format
msgid ""
"\n"
"*** %s: directory ***\n"
"\n"
msgstr ""
"\n"
"*** %s: Verzeichnis ***\n"
"\n"

#. simple ELF detection
#: text-utils/more.c:564
#, c-format
msgid ""
"\n"
"******** %s: Not a text file ********\n"
"\n"
msgstr ""
"\n"
"******** %s: Keine Textdatei ********\n"
"\n"

#: text-utils/more.c:667
msgid "[Use q or Q to quit]"
msgstr "[Benutzen Sie q oder Q zum Beenden]"

#: text-utils/more.c:847
msgid "--More--"
msgstr "--Mehr--"

#: text-utils/more.c:849
#, c-format
msgid "(Next file: %s)"
msgstr "(Nächste Datei: %s)"

#: text-utils/more.c:855
msgid "[Press space to continue, 'q' to quit.]"
msgstr "[Leertaste zum Fortfahren, »q« zum Beenden.]"

#: text-utils/more.c:1190
#, fuzzy, c-format
msgid "...back %d pages"
msgstr "... %d Seiten zurück"

#: text-utils/more.c:1192
#, fuzzy
msgid "...back 1 page"
msgstr "... %d Seiten zurück"

#: text-utils/more.c:1233
#, c-format
msgid "...skipping %d line"
msgstr "...überspringe %d Zeilen"

#: text-utils/more.c:1274
msgid ""
"\n"
"***Back***\n"
"\n"
msgstr ""
"\n"
"***Zurück***\n"
"\n"

#: text-utils/more.c:1331
msgid "Can't open help file"
msgstr "Konnte die Hilfedatei nicht öffnen"

#: text-utils/more.c:1361 text-utils/more.c:1365
msgid "[Press 'h' for instructions.]"
msgstr "[Drücken Sie »h« für Hilfe.]"

#: text-utils/more.c:1399
#, c-format
msgid "\"%s\" line %d"
msgstr "\"%s\" Zeile %d"

#: text-utils/more.c:1401
#, c-format
msgid "[Not a file] line %d"
msgstr "[Keine normale Datei] Zeile %d"

#: text-utils/more.c:1485
msgid "  Overflow\n"
msgstr "  Überlauf\n"

#: text-utils/more.c:1532
msgid "...skipping\n"
msgstr "...Überspringe\n"

#: text-utils/more.c:1562
msgid "Regular expression botch"
msgstr "Fehler beim Ausführen von »re_exec()«"

#: text-utils/more.c:1574
msgid ""
"\n"
"Pattern not found\n"
msgstr ""
"\n"
"Muster wurde nicht gefunden\n"

#: text-utils/more.c:1577
msgid "Pattern not found"
msgstr "Muster wurde nicht gefunden"

#: text-utils/more.c:1638
msgid "can't fork\n"
msgstr "Kann keinen neuen Prozess erzeugen\n"

#: text-utils/more.c:1677
msgid ""
"\n"
"...Skipping "
msgstr ""
"\n"
"...Springe "

#: text-utils/more.c:1682
#, fuzzy
msgid "...Skipping to file "
msgstr "...Springe "

#: text-utils/more.c:1684
#, fuzzy
msgid "...Skipping back to file "
msgstr "zurück zur Datei "

#: text-utils/more.c:1918
msgid "Line too long"
msgstr "Zeile ist zu lang"

#: text-utils/more.c:1961
msgid "No previous command to substitute for"
msgstr "Kein vorheriger Befehl, der eingefügt werden könnte"

#: text-utils/odsyntax.c:133
msgid "od: od(1) has been deprecated for hexdump(1).\n"
msgstr ""

#: text-utils/odsyntax.c:136
#, c-format
msgid "od: hexdump(1) compatibility doesn't support the -%c option%s\n"
msgstr ""

#: text-utils/odsyntax.c:137
msgid "; see strings(1)."
msgstr ""

#: text-utils/parse.c:63
#, c-format
msgid "hexdump: can't read %s.\n"
msgstr "hexdump: Konnte %s nicht lesen.\n"

#: text-utils/parse.c:68
msgid "hexdump: line too long.\n"
msgstr "hexdump: Zeile ist zu lang.\n"

#: text-utils/parse.c:406
msgid "hexdump: byte count with multiple conversion characters.\n"
msgstr ""

#: text-utils/parse.c:490
#, c-format
msgid "hexdump: bad byte count for conversion character %s.\n"
msgstr ""

#: text-utils/parse.c:497
#, ycp-format
msgid "hexdump: %%s requires a precision or a byte count.\n"
msgstr ""

#: text-utils/parse.c:503
#, fuzzy, c-format
msgid "hexdump: bad format {%s}\n"
msgstr "hexdump: Ungültiges Format (%s)\n"

#: text-utils/parse.c:509
msgid "hexdump: bad conversion character %%%s.\n"
msgstr ""

#: text-utils/rev.c:113
msgid "Unable to allocate bufferspace\n"
msgstr "Konnte keinen Speicher für einen Puffer reservieren.\n"

#: text-utils/rev.c:156
msgid "usage: rev [file ...]\n"
msgstr "Aufruf: rev [Datei ...]\n"

#: text-utils/ul.c:143
#, c-format
msgid "usage: %s [ -i ] [ -tTerm ] file...\n"
msgstr "Aufruf: %s [ -i ] [ -t Terminalname ] Datei ...\n"

#: text-utils/ul.c:154
msgid "trouble reading terminfo"
msgstr "Probleme beim Lesen der terminfo-Datenbank"

#: text-utils/ul.c:244
#, c-format
msgid "Unknown escape sequence in input: %o, %o\n"
msgstr "Unbekannte Escape-Sequenz in der Eingabe: %o, %o\n"

#: text-utils/ul.c:427
msgid "Unable to allocate buffer.\n"
msgstr "Konnte keinen Speicher für einen Puffer reservieren.\n"

#: text-utils/ul.c:588
msgid "Input line too long.\n"
msgstr "Eingabezeile ist zu lang.\n"

#: text-utils/ul.c:601
msgid "Out of memory when growing buffer.\n"
msgstr "Speicher ist alle beim Vergrößern eines Puffers.\n"

#~ msgid "BSD/386"
#~ msgstr "BSD/386"

#~ msgid "new "
#~ msgstr "neue "

#~ msgid "to file "
#~ msgstr "zur Datei "

#~ msgid "Warning: partition %d has an odd number of sectors.\n"
#~ msgstr "Warnung: Partition %d hat eine ungerade Anzahl an Sektoren.\n"

#~ msgid ""
#~ "Re-read table failed with error %d: %s.\n"
#~ "Reboot your system to ensure the partition table is updated.\n"
#~ msgstr ""
#~ "Das Kernel konnte die Partitionstabelle nicht erneut lesen (Fehler %d):\n"
#~ "%s\n"
#~ "Rebooten Sie das System, um sicherzustellen, dass die Partitionstabelle "
#~ "neu gelesen wird.\n"

#~ msgid "AST Windows swapfile"
#~ msgstr "AST Windows swapfile"

#~ msgid "usage: banner [-w width]\n"
#~ msgstr "Aufruf: banner [-w Breite]\n"

# "Meldung"
#~ msgid "Message: "
#~ msgstr "Meldung: "

#~ msgid "The character '%c' is not in my character set"
#~ msgstr "Das Zeichen »%c« ist nicht im Zeichensatz vorhanden"

#~ msgid "Message '%s' is OK\n"
#~ msgstr "Meldung »%s« ist in Ordnung\n"

# XXX - Merge with next strings.
#~ msgid "Usage: %s [ -s shell ] "
#~ msgstr "Aufruf: %s [ -s Shell ] "

#~ msgid "[ --list-shells ] [ --help ] [ --version ]\n"
#~ msgstr "[ --list-shells ] [ --help ] [ --version ]\n"

#~ msgid "       [ username ]\n"
#~ msgstr "        [ Benutzername ]\n"

#~ msgid "not mounted anything"
#~ msgstr "Es wurde nichts gemountet"

#, fuzzy
#~ msgid "Not set\n"
#~ msgstr "Nicht gesetzt\n"

#, fuzzy
#~ msgid "  swapdev ...                     same as rdev -s"
#~ msgstr "  swapdev ...                     Das gleiche wie rdev -s"

#~ msgid "Invalid values in hardware clock: %2d/%.2d/%.2d %.2d:%.2d:%.2d\n"
#~ msgstr "Ungültige Werte in Hardwareuhr: %2d/%.2d/%.2d %.2d:%.2d:%.2d\n"

#~ msgid ""
#~ "Hw clock time : %2d/%.2d/%.2d %.2d:%.2d:%.2d = %d seconds since 1969\n"
#~ msgstr ""
#~ "Zeit der Hardwareuhr: %2d/%.2d/%.2d %.2d:%.2d:%.2d = %d Sekunden seit "
#~ "1969\n"

# Egger
#~ msgid "Time read from Hardware Clock: %02d:%02d:%02d\n"
#~ msgstr "Zeit gelesen aus Hardwareuhr: %02d:%02d:%02d\n"

#~ msgid "ioctl() to open /dev/tty1 failed"
#~ msgstr "ioctl() konnte /dev/tty1 nicht öffnen."

#~ msgid "Usage: %s [-c] [-v0|-v1] /dev/name [blocks]\n"
#~ msgstr "Aufruf: %s [-c] [-v0|-v1] /dev/Name [Größe in kB]\n"

#~ msgid "SGI rxlvol"
#~ msgstr "SGI rxlvol"

#~ msgid "%s: open for update: %m"
#~ msgstr "Konnte %s nicht zum Aktualisieren öffnen: %m"

#~ msgid "usage: script [-a] [file]\n"
#~ msgstr "Aufruf: script [-a] [Datei]\n"

#~ msgid "usage: tsort [ inputfile ]\n"
#~ msgstr "Aufruf: tsort [ Eingabedatei ]\n"

#, fuzzy
#~ msgid "tsort: odd data count.\n"
#~ msgstr "tsort: Ungerade Anzahl Daten.\n"

#~ msgid "tsort: cycle in data.\n"
#~ msgstr "tsort: Zyklus in den Daten.\n"

#~ msgid "tsort: internal error -- could not find cycle.\n"
#~ msgstr "tsort: Interner Fehler -- konnte den Zyklus nicht finden.\n"

#~ msgid "mount: warning: cannot change mounted device with a remount\n"
#~ msgstr ""
#~ "mount: Warnung: Das Gerät kann nicht mit einem »remount« geändert werden\n"

#~ msgid "mount: warning: cannot change filesystem type with a remount\n"
#~ msgstr ""
#~ "mount: Der Dateisystemtyp kann nicht mit einem »remount« geändert werden\n"

#~ msgid "Cannot get loop info"
#~ msgstr "Konnte keine Informationen über das »loop«-Gerät erhalten"

#~ msgid ""
#~ "Usage: mount [-hV]\n"
#~ "       mount -a [-nfFrsvw] [-t vfstypes]\n"
#~ "       mount [-nfrsvw] [-o options] special | node\n"
#~ "       mount [-nfrsvw] [-t vfstype] [-o options] special node\n"
#~ "       A special device can be indicated by  -L label  or  -U uuid .\n"
#~ msgstr ""
#~ "Aufruf: mount [-hV]\n"
#~ "        mount -a [-nfFrsvw] [-t VFS-Typen]\n"
#~ "        mount [-nfrsvw] [-o Optionen] Spezialdatei | Verzeichnis\n"
#~ "        mount [-nfrsvw] [-t VFS-Typ] [-o Optionen] Gerät Verzeichnis\n"
#~ "        Das Gerät kann auch durch -L Label oder -U UUID angegeben "
#~ "werden.\n"

# This one is for Debian
#~ msgid "not mounting anything"
#~ msgstr "Es wird nichts gemountet"

#, fuzzy
#~ msgid "send_time=%srcv_time=%schange_time=%s"
#~ msgstr "Sendezeit = %sEmpfangszeit = %sÄnderungszeit = %s"

#, fuzzy
#~ msgid "Not Set\n"
#~ msgstr "Nicht gesetzt\n"

#~ msgid "usage: %s [-dfln] [+linenum | +/pattern] name1 name2 ...\n"
#~ msgstr ""
#~ "Aufruf: %s [-dfln] [+Zeilennummer | +/Muster] Dateiname1 Dateiname2 ...\n"

#~ msgid "Typematic Rate set to %.1f cps (delay = %d ms)\n"
#~ msgstr ""
#~ "Die Tastaturwiederholrate wurde auf %.1f cps gesetzt\n"
#~ "Die Verzögerungszeit wurde auf %dms gesetzt\n"

#~ msgid "Usage: kbdrate [-V] [-s] [-r rate] [-d delay]\n"
#~ msgstr "Aufruf: kbdrate [-V] [-s] [-r Rate] [-d Verzögerungszeit]\n"

#~ msgid "Cannot open /dev/port"
#~ msgstr "Konnte /dev/port nicht öffnen"

#~ msgid "Unable to open /dev/rtc"
#~ msgstr "Konnte /dev/rtc nicht öffnen"

#~ msgid "%s%d contains no disklabel.\n"
#~ msgstr "%s%d enthält keinen »disklabel«.\n"

#~ msgid "mount: %s has wrong major or minor number"
#~ msgstr "mount: %s hat eine falsche Major oder Minor Geräte-Nummer"

#~ msgid "mount: %s:%s failed, reason given by server: %s\n"
#~ msgstr ""
#~ "mount: %s:%s schlug fehl, Der folgende Grund wurde vom Server angegeben:\n"
#~ "       %s\n"

#~ msgid "Cannot read disk drive geometry"
#~ msgstr "Konnte die Festplattengeometrie nicht lesen"

#~ msgid "Cannot derive a geometry from an empty partition table"
#~ msgstr ""
#~ "Konnte die Geometrie nicht aus einer leeren Partitionstabelle ableiten"

#~ msgid "Cannot derive a geometry from the partition table"
#~ msgstr "Konnte die Geometrie nicht aus der Partitionstabelle ableiten"

#~ msgid "%s: unrecognized option `--%s'\n"
#~ msgstr "%s: unbekannte Option »--%s«\n"

#~ msgid "'/' in \"%s\""
#~ msgstr "»%s« enthält einen »/«"