mirror of
https://github.com/GrammaticalFramework/gf-rgl.git
synced 2026-06-08 06:36:32 -06:00
9649 lines
344 KiB
Plaintext
9649 lines
344 KiB
Plaintext
--# -path=.:../prelude:../abstract:../common::../english
|
|
|
|
concrete DictEngGer of DictEngAbs = CatGer **
|
|
open ResGer, DictGer, LexiconGer, Prelude,
|
|
MorphoGer, MakeStructuralGer, (X = ConstructX),
|
|
(P = ParadigmsGer), IrregGer
|
|
|
|
|
|
in {
|
|
|
|
|
|
lin
|
|
|
|
abandon_V2 = P.dirV2 (DictGer.verlassen_V) ;
|
|
abase_V2 = P.dirV2 (DictGer.erniedrigen_V) ;
|
|
abasement_N = DictGer.erniedrigung_N ;
|
|
abash_V2 = P.dirV2 (DictGer.beschaemen_V) ;
|
|
abatement_N = DictGer.abnahme_N ;
|
|
abattoir_N = DictGer.schlachthof_N ;
|
|
abbey_N = DictGer.abtei_N ;
|
|
abbot_N = DictGer.abt_N ;
|
|
abbreviate_V2 = P.dirV2 (DictGer.kuerzen_V) ;
|
|
abbreviation_N = DictGer.abkuerzung_N ;
|
|
abdicate_V = DictGer.verweigern_V ;
|
|
abdicate_V2 = P.dirV2 (DictGer.verweigern_V) ;
|
|
abdication_N = DictGer.abdankung_N ;
|
|
abdomen_N = DictGer.bauch_N ;
|
|
abduct_V2 = P.dirV2 (DictGer.entfuehren_V) ;
|
|
abduction_N = DictGer.abduktion_N ;
|
|
aberration_N = DictGer.aberration_N ;
|
|
abet_V = DictGer.ermutigen_V ;
|
|
abet_V2 = P.dirV2 (DictGer.ermutigen_V) ;
|
|
abhorrence_N = DictGer.ekel_N ;
|
|
abide_V = DictGer.weilen_V ;
|
|
abide_V2 = P.dirV2 (DictGer.weilen_V) ;
|
|
ability_N = DictGer.faehigkeit_N ;
|
|
abject_A = DictGer.bitter_A ;
|
|
ablaut_N = DictGer.ablaut_N ;
|
|
able_A = DictGer.faehig_A ;
|
|
abnormal_A = DictGer.abnormal_A ;
|
|
abnormality_N = DictGer.abweichung_N ;
|
|
abode_N = DictGer.aufenthalt_N ;
|
|
abolish_V2 = P.dirV2 (DictGer.vernichten_V) ;
|
|
abolition_N = DictGer.abschaffung_N ;
|
|
abominable_A = DictGer.abscheulich_A ;
|
|
aboriginal_A = DictGer.einheimisch_A ;
|
|
abortion_N = DictGer.abtreibung_N ;
|
|
abortionist_N = DictGer.engelmacher_N ;
|
|
abortive_A = DictGer.rudimentaer_A ;
|
|
abrasion_N = DictGer.abrasion_N ;
|
|
abridge_V2 = P.dirV2 (DictGer.kuerzen_V) ;
|
|
abridgement_N = DictGer.auszug_N ;
|
|
abrupt_A = DictGer.abrupt_A ;
|
|
absence_N = DictGer.abwesenheit_N ;
|
|
absent_A = DictGer.abwesend_A ;
|
|
absinthe_N = DictGer.absinth_N ;
|
|
absolute_A = DictGer.absolut_A ;
|
|
absorb_V2 = P.dirV2 (DictGer.absorbieren_V) ;
|
|
absorption_N = DictGer.absorption_N ;
|
|
abstract_N = DictGer.auszug_N ;
|
|
abstraction_N = DictGer.abstraktion_N ;
|
|
absurd_A = DictGer.absurd_A ;
|
|
absurdity_N = DictGer.absurditaet_N ;
|
|
abuse_N = DictGer.missbrauch_N ;
|
|
abut_V = DictGer.grenzen_7_V ;
|
|
abysm_N = DictGer.abgrund_N ;
|
|
abysmal_A = DictGer.erbaermlich_A ;
|
|
abyss_N = DictGer.abgrund_N ;
|
|
acacia_N = DictGer.akazie_N ;
|
|
academician_N = DictGer.akademiker_N ;
|
|
academy_N = DictGer.akademie_N ;
|
|
accelerate_V = DictGer.beschleunigen_V ;
|
|
accelerate_V2 = P.dirV2 (DictGer.beschleunigen_V) ;
|
|
acceleration_N = DictGer.beschleunigung_N ;
|
|
accelerator_N = DictGer.gaspedal_N ;
|
|
accent_N = DictGer.akzent_N ;
|
|
accentuate_V2 = P.dirV2 (DictGer.akzentuieren_V) ;
|
|
accept_V = DictGer.akzeptieren_V ;
|
|
accept_V2 = P.dirV2 (DictGer.akzeptieren_V) ;
|
|
acceptable_A = DictGer.annehmbar_A ;
|
|
acceptance_N = DictGer.annahme_N ;
|
|
access_N = DictGer.zugang_N ;
|
|
accession_N = DictGer.antritt_N ;
|
|
accident_N = DictGer.unfall_N ;
|
|
accidental_A = DictGer.versehentlich_A ;
|
|
acclaim_V2 = P.dirV2 (DictGer.applaudieren_V) ;
|
|
accommodation_N = DictGer.anpassung_N ;
|
|
accompaniment_N = DictGer.begleitung_N ;
|
|
accompany_V2 = P.dirV2 (DictGer.begleiten_V) ;
|
|
accomplice_N = DictGer.komplize_N ;
|
|
accord_N = DictGer.akkord_N ;
|
|
accordion_N = DictGer.akkordeon_N ;
|
|
account_N = DictGer.begruendung_N ;
|
|
accountable_A = DictGer.verantwortlich_A ;
|
|
accredit_V2 = P.dirV2 (DictGer.akkreditieren_V) ;
|
|
accretion_N = DictGer.zunahme_N ;
|
|
accumulation_N = DictGer.anhaeufung_N ;
|
|
accumulator_N = DictGer.akkumulator_N ;
|
|
accurate_A = DictGer.exakt_A ;
|
|
accusation_N = DictGer.anklage_N ;
|
|
ace_N = DictGer.ass_N ;
|
|
achieve_V2 = P.dirV2 (DictGer.erlangen_V) ;
|
|
acid_A = DictGer.sauer_A ;
|
|
acknowledge_V = DictGer.bekennen_V ;
|
|
acknowledge_V2 = P.dirV2 (DictGer.bekennen_V) ;
|
|
acknowledgement_N = DictGer.anerkennung_N ;
|
|
acne_N = DictGer.akne_N ;
|
|
acolyte_N = DictGer.akolyth_N ;
|
|
aconite_N = DictGer.eisenhut_N ;
|
|
acorn_N = DictGer.eichel_N ;
|
|
acoustic_A = DictGer.akustisch_A ;
|
|
acoustics_N = DictGer.akustik_N ;
|
|
acquire_V2 = P.dirV2 (DictGer.akquirieren_V) ;
|
|
acquisition_N = DictGer.erwerb_N ;
|
|
acquit_V2 = P.dirV2 (DictGer.begleichen_V) ;
|
|
acrobat_N = DictGer.akrobat_N ;
|
|
acronym_N = DictGer.akronym_N ;
|
|
act_N = DictGer.akt_N ;
|
|
acting_A = DictGer.stellvertretend_A ;
|
|
action_N = DictGer.aktion_N ;
|
|
activation_N = DictGer.activating_N ;
|
|
active_A = DictGer.aktiv_A ;
|
|
activist_N = DictGer.aktivist_N ;
|
|
activity_N = DictGer.aktivitaet_N ;
|
|
actor_N = DictGer.schauspieler_N ;
|
|
actress_N = DictGer.schauspielerin_N ;
|
|
actual_A = DictGer.aktuell_A ;
|
|
acupuncture_N = DictGer.akupunktur_N ;
|
|
acute_A = DictGer.scharf_A ;
|
|
adage_N = DictGer.sprichwort_N ;
|
|
adamant_A = DictGer.felsenfest_A ;
|
|
adaptation_N = DictGer.anpassung_N ;
|
|
adapter_N = DictGer.adapter_N ;
|
|
add_V = DictGer.addieren_V ;
|
|
add_V2 = P.dirV2 (DictGer.addieren_V) ;
|
|
addendum_N = DictGer.anhang_N ;
|
|
adder_N = DictGer.kreuzotter_N ;
|
|
addiction_N = DictGer.abhaengigkeit_N ;
|
|
addition_N = DictGer.addition_N ;
|
|
additional_A = DictGer.zusaetzlich_A ;
|
|
address_N = DictGer.adresse_N ;
|
|
addressee_N = DictGer.empfaenger_N ;
|
|
adequate_A = DictGer.adaequat_A ;
|
|
adhere_V = DictGer.befolgen_V ;
|
|
adherence_N = DictGer.unterstuetzung_N ;
|
|
adhesion_N = DictGer.adhaesion_N ;
|
|
adjacent_A = DictGer.benachbart_A ;
|
|
adjunct_N = DictGer.bestimmung_N ;
|
|
adjust_V = DictGer.berichtigen_V ;
|
|
adjust_V2 = P.dirV2 (DictGer.berichtigen_V) ;
|
|
adjustment_N = DictGer.anpassung_N ;
|
|
adjutant_N = DictGer.adjutant_N ;
|
|
administration_N = DictGer.verwaltung_N ;
|
|
administrative_A = DictGer.administrativ_A ;
|
|
administrator_N = DictGer.administrator_N ;
|
|
admirable_A = DictGer.bewundernswert_A ;
|
|
admiration_N = DictGer.bewunderung_N ;
|
|
admissible_A = DictGer.akzeptabel_A ;
|
|
admonish_V2 = P.dirV2 (DictGer.warnen_V) ;
|
|
adopt_V2 = P.dirV2 (DictGer.adoptieren_V) ;
|
|
adoption_N = DictGer.adoption_N ;
|
|
adorable_A = DictGer.bezaubernd_A ;
|
|
adore_V2 = P.dirV2 (DictGer.verehren_V) ;
|
|
adorn_V2 = P.dirV2 (DictGer.schmuecken_4_V) ;
|
|
adult_N = DictGer.erwachsene_N ;
|
|
adultery_N = DictGer.ehebruch_N ;
|
|
advancement_N = DictGer.fortschritt_N ;
|
|
advantage_N = DictGer.vorteil_N ;
|
|
advantageous_A = DictGer.vorteilhaft_A ;
|
|
advent_N = DictGer.ankunft_N ;
|
|
adventure_N = DictGer.abenteuer_N ;
|
|
adventurer_N = DictGer.abenteurerin_N ;
|
|
adventuress_N = DictGer.abenteuerin_N ;
|
|
adventurous_A = DictGer.abenteuerlich_A ;
|
|
adverb_N = DictGer.adverb_N ;
|
|
adverbial_A = DictGer.adverbial_A ;
|
|
adversary_N = DictGer.gegner_N ;
|
|
adverse_A = DictGer.widrig_A ;
|
|
advert_N = DictGer.werbung_N ;
|
|
advice_N = DictGer.rat_N ;
|
|
advise_V = DictGer.beraten_V ;
|
|
advise_V2 = P.dirV2 (DictGer.beraten_V) ;
|
|
adviser_N = DictGer.ratgeber_N ;
|
|
advocate_N = DictGer.rechtsanwalt_N ;
|
|
aerodynamic_A = DictGer.aerodynamisch_A ;
|
|
aeroplane_N = DictGer.flugzeug_N ;
|
|
aesthetic_A = DictGer.aesthetisch_A ;
|
|
aesthetics_N = DictGer.aesthetik_N ;
|
|
aetiology_N = DictGer.aetiologie_N ;
|
|
affable_A = DictGer.umgaenglich_A ;
|
|
affair_N = DictGer.affaere_N ;
|
|
affect_V2 = P.dirV2 (DictGer.beeinflussen_V) ;
|
|
affection_N = DictGer.zuneigung_N ;
|
|
affix_N = DictGer.affix_N ;
|
|
afraid_A = DictGer.aengstlich_A ;
|
|
african_A = DictGer.afrikanisch_A ;
|
|
afrikaner_N = DictGer.afrikaner_N ;
|
|
aftermath_N = DictGer.folge_N ;
|
|
afternoon_N = DictGer.nachmittag_N ;
|
|
agave_N = DictGer.agave_N ;
|
|
age_N = DictGer.alter_N ;
|
|
agency_N = DictGer.agentur_N ;
|
|
agenda_N = DictGer.agenda_N ;
|
|
agent_N = DictGer.agent_N ;
|
|
agglomeration_N = DictGer.ansammlung_N ;
|
|
agglutinative_A = DictGer.agglutinierend_A ;
|
|
aggravate_V2 = P.dirV2 (DictGer.erschweren_V) ;
|
|
aggression_N = DictGer.aggression_N ;
|
|
aggressive_A = DictGer.aggressiv_A ;
|
|
aggressiveness_N = DictGer.aggressivitaet_N ;
|
|
aggressor_N = DictGer.aggressor_N ;
|
|
agile_A = DictGer.agil_A ;
|
|
agitator_N = DictGer.agitator_N ;
|
|
agnostic_N = DictGer.agnostiker_N ;
|
|
agony_N = DictGer.agonie_N ;
|
|
agoraphobia_N = DictGer.agoraphobie_N ;
|
|
agree_V = DictGer.akzeptieren_V ;
|
|
agree_V2 = P.dirV2 (DictGer.akzeptieren_V) ;
|
|
agreement_N = DictGer.kongruenz_N ;
|
|
agricultural_A = DictGer.landwirtschaftlich_A ;
|
|
agriculture_N = DictGer.landwirtschaft_N ;
|
|
aid_N = DictGer.helfer_N ;
|
|
aim_N = DictGer.ziel_N ;
|
|
air_N = DictGer.arie_N ;
|
|
aircraft_N = DictGer.flugzeug_N ;
|
|
airfield_N = DictGer.flugplatz_N ;
|
|
airline_N = DictGer.fluggesellschaft_N ;
|
|
airplane_N = LexiconGer.airplane_N ;
|
|
airport_N = DictGer.flughafen_N ;
|
|
airscrew_N = DictGer.propeller_N ;
|
|
airship_N = DictGer.luftschiff_N ;
|
|
airtight_A = DictGer.hermetisch_A ;
|
|
aisle_N = DictGer.gang_N ;
|
|
akin_A = DictGer.verwandt_A ;
|
|
alarm_N = DictGer.alarm_N ;
|
|
alb_N = DictGer.albe_N ;
|
|
albatross_N = DictGer.albatros_N ;
|
|
album_N = DictGer.album_N ;
|
|
albumen_N = DictGer.eiweiss_N ;
|
|
alchemist_N = DictGer.alchemist_N ;
|
|
alcohol_N = DictGer.alkohol_N ;
|
|
alder_N = DictGer.erle_N ;
|
|
alfalfa_N = DictGer.luzerne_N ;
|
|
alga_N = DictGer.alge_N ;
|
|
algebra_N = DictGer.algebra_N ;
|
|
alibi_N = DictGer.alibi_N ;
|
|
alien_N = DictGer.auslaender_N ;
|
|
alignment_N = DictGer.konstellation_N ;
|
|
alive_A = DictGer.lebendig_A ;
|
|
allege_V2 = P.dirV2 (DictGer.behaupten_V) ;
|
|
allegoric_A = DictGer.allegorisch_A ;
|
|
allegorical_A = DictGer.allegorisch_A ;
|
|
allergen_N = DictGer.allergen_N ;
|
|
allergic_A = DictGer.allergisch_A ;
|
|
allergy_N = DictGer.allergie_N ;
|
|
alleviation_N = DictGer.erleichterung_N ;
|
|
alley_N = DictGer.gasse_N ;
|
|
alliance_N = DictGer.allianz_N ;
|
|
alligator_N = DictGer.alligator_N ;
|
|
allow_V = DictGer.akzeptieren_V ;
|
|
allow_V2 = P.dirV2 (DictGer.akzeptieren_V) ;
|
|
allowance_N = DictGer.erlaubnis_N ;
|
|
alloy_N = DictGer.legierung_N ;
|
|
allure_N = DictGer.anziehungskraft_N ;
|
|
allusion_N = DictGer.anspielung_N ;
|
|
almighty_A = DictGer.allmaechtig_A ;
|
|
almond_N = DictGer.mandel_N ;
|
|
aloe_N = DictGer.aloe_N ;
|
|
alone_A = DictGer.allein_A ;
|
|
alpaca_N = DictGer.alpaka_N ;
|
|
alphabet_N = DictGer.alphabet_N ;
|
|
alphabetical_A = DictGer.alphabetisch_A ;
|
|
altar_N = DictGer.altar_N ;
|
|
alternative_A = DictGer.alternativ_A ;
|
|
altitude_N = DictGer.hoehe_N ;
|
|
altruistic_A = DictGer.altruistisch_A ;
|
|
aluminium_N = DictGer.aluminium_N ;
|
|
alumnus_N = DictGer.student_N ;
|
|
amalgamate_V = DictGer.amalgamieren_V ;
|
|
amalgamate_V2 = P.dirV2 (DictGer.amalgamieren_V) ;
|
|
amanuensis_N = DictGer.schreiber_N ;
|
|
ambassador_N = DictGer.botschafter_N ;
|
|
amber_N = DictGer.bernstein_N ;
|
|
ambergris_N = DictGer.ambra_N ;
|
|
ambiguous_A = DictGer.unklar_A ;
|
|
ambitious_A = DictGer.ambitioniert_A ;
|
|
ambivalence_N = DictGer.ambivalenz_N ;
|
|
ambrosia_N = DictGer.ambrosia_N ;
|
|
ambulance_N = DictGer.krankenwagen_N ;
|
|
ambush_N = DictGer.hinterhalt_N ;
|
|
ameliorate_V = DictGer.verbessern_V ;
|
|
ameliorate_V2 = P.dirV2 (DictGer.verbessern_V) ;
|
|
amelioration_N = DictGer.verbesserung_N ;
|
|
amenable_A = DictGer.zugaenglich_A ;
|
|
amend_V = DictGer.verbessern_V ;
|
|
amend_V2 = P.dirV2 (DictGer.verbessern_V) ;
|
|
amendment_N = DictGer.aenderung_N ;
|
|
amenity_N = DictGer.annehmlichkeit_N ;
|
|
american_N = DictGer.amerikaner_N ;
|
|
amethyst_N = DictGer.amethyst_N ;
|
|
amiable_A = DictGer.liebenswuerdig_A ;
|
|
ammunition_N = DictGer.munition_N ;
|
|
amnesty_N = DictGer.amnestie_N ;
|
|
amoeba_N = DictGer.amoebe_N ;
|
|
amorphous_A = DictGer.amorph_A ;
|
|
amortization_N = DictGer.abschreibung_N ;
|
|
amount_N = DictGer.number_N ;
|
|
ampere_N = DictGer.ampere_N ;
|
|
amphora_N = DictGer.amphore_N ;
|
|
ample_A = DictGer.ueppig_A ;
|
|
amplification_N = DictGer.verstaerkung_N ;
|
|
amplify_V2 = P.dirV2 (DictGer.verstaerken_V) ;
|
|
amplitude_N = DictGer.amplitude_N ;
|
|
ampoule_N = DictGer.ampulle_N ;
|
|
amputate_V2 = P.dirV2 (DictGer.amputieren_V) ;
|
|
amputation_N = DictGer.amputation_N ;
|
|
amulet_N = DictGer.amulett_N ;
|
|
amuse_V2 = P.dirV2 (DictGer.amuesieren_V) ;
|
|
anachronism_N = DictGer.anachronismus_N ;
|
|
anachronistic_A = DictGer.anachronistisch_A ;
|
|
anaesthesia_N = DictGer.anaesthesie_N ;
|
|
anagram_N = DictGer.anagramm_N ;
|
|
analgesic_N = DictGer.analgetikum_N ;
|
|
analogous_A = DictGer.analog_A ;
|
|
analogy_N = DictGer.analogie_N ;
|
|
analysis_N = DictGer.analyse_N ;
|
|
analyst_N = DictGer.analytiker_N ;
|
|
analytic_A = DictGer.analytisch_A ;
|
|
anarchy_N = DictGer.anarchie_N ;
|
|
anathema_N = DictGer.kirchenbann_N ;
|
|
anatomical_A = DictGer.anatomisch_A ;
|
|
anatomist_N = DictGer.anatom_N ;
|
|
anatomy_N = DictGer.anatomie_N ;
|
|
ancestor_N = DictGer.ahne_N ;
|
|
anchor_N = DictGer.anker_N ;
|
|
anchorage_N = DictGer.ankerplatz_N ;
|
|
anchovy_N = DictGer.sardelle_N ;
|
|
ancient_A = DictGer.antik_A ;
|
|
anecdote_N = DictGer.anekdote_N ;
|
|
anemone_N = DictGer.anemone_N ;
|
|
angel_N = DictGer.engel_N ;
|
|
angle_N = DictGer.blickwinkel_N ;
|
|
angler_N = DictGer.angler_N ;
|
|
anglicism_N = DictGer.anglizismus_N ;
|
|
angry_A = DictGer.boese_A ;
|
|
anguish_N = DictGer.agonie_N ;
|
|
angular_A = DictGer.eckig_A ;
|
|
aniline_N = DictGer.anilin_N ;
|
|
animal_N = LexiconGer.animal_N ;
|
|
animate_A = DictGer.belebt_A ;
|
|
animosity_N = DictGer.abneigung_N ;
|
|
anise_N = DictGer.anis_N ;
|
|
ankle_N = DictGer.knoechel_N ;
|
|
annexation_N = DictGer.annexion_N ;
|
|
annihilate_V2 = P.dirV2 (DictGer.vernichten_V) ;
|
|
anniversary_N = DictGer.hochzeitstag_N ;
|
|
annotation_N = DictGer.anmerkung_N ;
|
|
announcement_N = DictGer.ankuendigung_N ;
|
|
announcer_N = DictGer.sprecher_N ;
|
|
annoy_V2 = P.dirV2 (DictGer.belaestigen_V) ;
|
|
annoying_A = DictGer.laestig_A ;
|
|
annual_A = DictGer.jaehrlich_A ;
|
|
annunciate_V2 = P.dirV2 (DictGer.verkuenden_V) ;
|
|
anoint_V2 = P.dirV2 (DictGer.schmieren_8_V) ;
|
|
anomalous_A = DictGer.anomal_A ;
|
|
anomaly_N = DictGer.anomalie_N ;
|
|
anonymous_A = DictGer.anonym_A ;
|
|
anorak_N = DictGer.anorak_N ;
|
|
answer_N = DictGer.antwort_N ;
|
|
ant_N = DictGer.ameise_N ;
|
|
antagonism_N = DictGer.antagonismus_N ;
|
|
antecedent_A = DictGer.vorausgehend_A ;
|
|
antelope_N = DictGer.antilope_N ;
|
|
antenna_N = DictGer.antenne_N ;
|
|
anthem_N = DictGer.hymne_N ;
|
|
anthropologist_N = DictGer.anthropologe_N ;
|
|
antibiotic_N = DictGer.antibiotikum_N ;
|
|
antibody_N = DictGer.antikoerper_N ;
|
|
antidote_N = DictGer.gegengift_N ;
|
|
antifreeze_N = DictGer.frostschutzmittel_N ;
|
|
antiquated_A = DictGer.antiquiert_A ;
|
|
antique_A = DictGer.antik_A ;
|
|
antiquity_N = DictGer.antike_N ;
|
|
antithesis_N = DictGer.antithese_N ;
|
|
antler_N = DictGer.geweih_N ;
|
|
anus_N = DictGer.after_N ;
|
|
anvil_N = DictGer.amboss_N ;
|
|
anxious_A = DictGer.aengstlich_A ;
|
|
aorta_N = DictGer.aorta_N ;
|
|
apartment_N = LexiconGer.apartment_N ;
|
|
apathetic_A = DictGer.apathisch_A ;
|
|
apathy_N = DictGer.apathie_N ;
|
|
ape_N = DictGer.affe_N ;
|
|
aperture_N = DictGer.blende_N ;
|
|
apex_N = DictGer.gipfel_N ;
|
|
aphasia_N = DictGer.aphasie_N ;
|
|
aphid_N = DictGer.blattlaus_N ;
|
|
aphorism_N = DictGer.aphorismus_N ;
|
|
apish_A = DictGer.affig_A ;
|
|
aplomb_N = DictGer.souveraenitaet_N ;
|
|
apocalyptic_A = DictGer.apokalyptisch_A ;
|
|
apogee_N = DictGer.apogaeum_N ;
|
|
apology_N = DictGer.entschuldigung_N ;
|
|
apoplectic_A = DictGer.apoplektisch_A ;
|
|
apoplexy_N = DictGer.apoplexy_N ;
|
|
apostle_N = DictGer.apostel_N ;
|
|
apostrophe_N = DictGer.apostroph_N ;
|
|
apothecary_N = DictGer.apotheke_N ;
|
|
apparatus_N = DictGer.apparat_N ;
|
|
apparent_A = DictGer.offenbar_A ;
|
|
appear_V = DictGer.erscheinen_V ;
|
|
appear_V2 = P.dirV2 (DictGer.erscheinen_V) ;
|
|
appendage_N = DictGer.extremitaet_N ;
|
|
appendectomy_N = DictGer.appendektomie_N ;
|
|
appendicitis_N = DictGer.appendizitis_N ;
|
|
appendix_N = DictGer.anhang_N ;
|
|
appetite_N = DictGer.appetite_N ;
|
|
applause_N = DictGer.applaus_N ;
|
|
apple_N = LexiconGer.apple_N ;
|
|
appliance_N = DictGer.apparat_N ;
|
|
applicable_A = DictGer.anwendbar_A ;
|
|
applicant_N = DictGer.bewerber_N ;
|
|
application_N = DictGer.antrag_N ;
|
|
apply_V = DictGer.benutzen_V ;
|
|
apply_V2 = P.dirV2 (DictGer.benutzen_V) ;
|
|
appointment_N = DictGer.berufung_N ;
|
|
apposition_N = DictGer.apposition_N ;
|
|
appraisal_N = DictGer.einschaetzung_N ;
|
|
appraise_V2 = P.dirV2 (DictGer.taxieren_V) ;
|
|
appreciate_V = DictGer.verstehen_V ;
|
|
appreciate_V2 = P.dirV2 (DictGer.verstehen_V) ;
|
|
appreciation_N = DictGer.anerkennung_N ;
|
|
apprehend_V2 = P.dirV2 (DictGer.begreifen_V) ;
|
|
apprehensive_A = DictGer.besorgt_A ;
|
|
apprentice_N = DictGer.lehrling_N ;
|
|
apprenticeship_N = DictGer.lehre_N ;
|
|
apprise_V2 = P.dirV2 (DictGer.benachrichtigen_V) ;
|
|
appropriate_A = DictGer.angebracht_A ;
|
|
approval_N = DictGer.genehmigung_N ;
|
|
apricot_N = DictGer.aprikose_N ;
|
|
apron_N = DictGer.schuerze_N ;
|
|
apse_N = DictGer.apsis_N ;
|
|
apt_A = DictGer.geeignet_A ;
|
|
aptitude_N = DictGer.begabung_N ;
|
|
aquarium_N = DictGer.aquarium_N ;
|
|
arabesque_N = DictGer.arabeske_N ;
|
|
arbiter_N = DictGer.schiedsrichter_N ;
|
|
arbitrary_A = DictGer.arbitraer_A ;
|
|
arc_N = DictGer.kurve_N ;
|
|
arcane_A = DictGer.geheim_A ;
|
|
archaeologist_N = DictGer.archaeologe_N ;
|
|
archangel_N = DictGer.erzengel_N ;
|
|
archbishop_N = DictGer.erzbischof_N ;
|
|
archdiocese_N = DictGer.erzbistum_N ;
|
|
archduke_N = DictGer.erzherzog_N ;
|
|
archer_N = DictGer.bogenschuetze_N ;
|
|
archery_N = DictGer.bogenschiessen_N ;
|
|
archipelago_N = DictGer.archipel_N ;
|
|
architect_N = DictGer.architekt_N ;
|
|
architecture_N = DictGer.architektur_N ;
|
|
arctic_A = DictGer.arktisch_A ;
|
|
arduous_A = DictGer.anstrengend_A ;
|
|
area_N = DictGer.gebiet_N ;
|
|
arena_N = DictGer.arena_N ;
|
|
argue_V = DictGer.argumentieren_V ;
|
|
argue_V2 = P.dirV2 (DictGer.argumentieren_V) ;
|
|
argument_N = DictGer.argument_N ;
|
|
aria_N = DictGer.arie_N ;
|
|
aristocracy_N = DictGer.aristokratie_N ;
|
|
aristocrat_N = DictGer.aristokrat_N ;
|
|
aristocratic_A = DictGer.adlig_A ;
|
|
ark_N = DictGer.arche_N ;
|
|
arm_N = DictGer.arm_N ;
|
|
armadillo_N = DictGer.guerteltier_N ;
|
|
armament_N = DictGer.ausruestung_N ;
|
|
armistice_N = DictGer.waffenstillstand_N ;
|
|
armpit_N = DictGer.achselhoehle_N ;
|
|
army_N = DictGer.armee_N ;
|
|
arnica_N = DictGer.arnika_N ;
|
|
aromatic_A = DictGer.aromatisch_A ;
|
|
arraignment_N = DictGer.anklage_N ;
|
|
arrange_V = DictGer.arrangieren_V ;
|
|
arrange_V2 = P.dirV2 (DictGer.arrangieren_V) ;
|
|
arrangement_N = DictGer.anordnung_N ;
|
|
arrest_N = DictGer.verhaftung_N ;
|
|
arrival_N = DictGer.ankunft_N ;
|
|
arrive_V = DictGer.erreichen_V ;
|
|
arrive_V2 = P.dirV2 (DictGer.erreichen_V) ;
|
|
arrogance_N = DictGer.arroganz_N ;
|
|
arrow_N = DictGer.pfeil_N ;
|
|
arsenal_N = DictGer.arsenal_N ;
|
|
arson_N = DictGer.brandstiftung_N ;
|
|
art_N = LexiconGer.art_N ;
|
|
arteriosclerosis_N = DictGer.arteriosklerose_N ;
|
|
artery_N = DictGer.arterie_N ;
|
|
artichoke_N = DictGer.artischocke_N ;
|
|
article_N = DictGer.artikel_N ;
|
|
articulate_A = DictGer.effektiv_A ;
|
|
articulation_N = DictGer.artikulation_N ;
|
|
artifact_N = DictGer.artefakt_N ;
|
|
artificial_A = DictGer.kuenstlich_A ;
|
|
artillery_N = DictGer.artillerie_N ;
|
|
artisan_N = DictGer.handwerker_N ;
|
|
artist_N = DictGer.kuenstler_N ;
|
|
artistic_A = DictGer.artistisch_A ;
|
|
asbestos_N = DictGer.asbest_N ;
|
|
ascent_N = DictGer.anstieg_N ;
|
|
ascetic_A = DictGer.asketisch_A ;
|
|
ash_N = DictGer.asche_N ;
|
|
ashtray_N = DictGer.aschenbecher_N ;
|
|
asian_N = DictGer.asiatin_N ;
|
|
ask_V = DictGer.bitten_0_V ;
|
|
ask_V2 = P.dirV2 (DictGer.bitten_0_V) ;
|
|
askew_A = DictGer.schief_A ;
|
|
asparagus_N = DictGer.spargel_N ;
|
|
aspect_N = DictGer.aspekt_N ;
|
|
aspen_N = DictGer.espe_N ;
|
|
asphalt_N = DictGer.asphalt_N ;
|
|
aspic_N = DictGer.suelze_N ;
|
|
aspiration_N = DictGer.aspiration_N ;
|
|
aspire_V = DictGer.streben_6_V ;
|
|
aspirin_N = DictGer.aspirin_N ;
|
|
ass_N = DictGer.arsch_N ;
|
|
assassin_N = DictGer.assassine_N ;
|
|
assassinate_V2 = P.dirV2 (DictGer.ermorden_V) ;
|
|
assassination_N = DictGer.ermordung_N ;
|
|
assault_N = DictGer.anschlag_N ;
|
|
assemble_V = DictGer.versammeln_V ;
|
|
assemble_V2 = P.dirV2 (DictGer.versammeln_V) ;
|
|
assembly_N = DictGer.baugruppe_N ;
|
|
assertion_N = DictGer.versicherung_N ;
|
|
assessment_N = DictGer.bewertung_N ;
|
|
asseverate_V2 = P.dirV2 (DictGer.beteuern_V) ;
|
|
asshole_N = DictGer.arschloch_N ;
|
|
assiduous_A = DictGer.fleissig_A ;
|
|
assimilate_V = DictGer.assimilieren_V ;
|
|
assimilate_V2 = P.dirV2 (DictGer.assimilieren_V) ;
|
|
assimilation_N = DictGer.assimilation_N ;
|
|
assistance_N = DictGer.hilfe_N ;
|
|
assumption_N = DictGer.auffahrt_N ;
|
|
aster_N = DictGer.aster_N ;
|
|
asterisk_N = DictGer.sternchen_N ;
|
|
asteroid_N = DictGer.asteroid_N ;
|
|
asthma_N = DictGer.asthma_N ;
|
|
astrologer_N = DictGer.astrologe_N ;
|
|
astronaut_N = DictGer.astronaut_N ;
|
|
astronomer_N = DictGer.astronom_N ;
|
|
astronomical_A = DictGer.astronomisch_A ;
|
|
astute_A = DictGer.gerissen_A ;
|
|
asylum_N = DictGer.asyl_N ;
|
|
asymmetrical_A = DictGer.asymmetrisch_A ;
|
|
asymptote_N = DictGer.asymptote_N ;
|
|
atelier_N = DictGer.atelier_N ;
|
|
atheist_N = DictGer.agnostiker_N ;
|
|
atheistic_A = DictGer.atheistisch_A ;
|
|
athlete_N = DictGer.athlet_N ;
|
|
atlas_N = DictGer.atlant_N ;
|
|
atmosphere_N = DictGer.atmosphaere_N ;
|
|
atmospheric_A = DictGer.atmosphaerisch_A ;
|
|
atom_N = DictGer.atom_N ;
|
|
atomic_A = DictGer.atomar_A ;
|
|
atonement_N = DictGer.busse_N ;
|
|
atrocious_A = DictGer.grauenhaft_A ;
|
|
atrocity_N = DictGer.grausamkeit_N ;
|
|
atrophy_N = DictGer.atrophie_N ;
|
|
attache_N = DictGer.attache_N ;
|
|
attachment_N = DictGer.anhang_N ;
|
|
attack_N = DictGer.anfall_N ;
|
|
attacker_N = DictGer.angreifer_N ;
|
|
attain_V = DictGer.erlangen_V ;
|
|
attain_V2 = P.dirV2 (DictGer.erlangen_V) ;
|
|
attempt_V2 = P.dirV2 (DictGer.versuchen_V) ;
|
|
attend_V = DictGer.beachten_V ;
|
|
attend_V2 = P.dirV2 (DictGer.beachten_V) ;
|
|
attention_N = DictGer.aufmerksamkeit_N ;
|
|
attentive_A = DictGer.aufmerksam_A ;
|
|
attic_N = DictGer.dachboden_N ;
|
|
attitude_N = DictGer.einstellung_N ;
|
|
attorney_N = DictGer.rechtsanwalt_N ;
|
|
attraction_N = DictGer.anziehung_N ;
|
|
attractive_A = DictGer.attraktiv_A ;
|
|
attribute_N = DictGer.attribut_N ;
|
|
attributive_A = DictGer.attributiv_A ;
|
|
aubergine_N = DictGer.aubergine_N ;
|
|
auction_N = DictGer.auktion_N ;
|
|
auctioneer_N = DictGer.auktionator_N ;
|
|
audacity_N = DictGer.frechheit_N ;
|
|
audible_A = DictGer.hoerbar_A ;
|
|
audience_N = DictGer.audienz_N ;
|
|
audit_N = DictGer.kontrolle_N ;
|
|
augur_N = DictGer.augur_N ;
|
|
aunt_N = DictGer.tante_N ;
|
|
auntie_N = DictGer.tante_N ;
|
|
aura_N = DictGer.aura_N ;
|
|
aureole_N = DictGer.heiligenschein_N ;
|
|
auricle_N = DictGer.ohrmuschel_N ;
|
|
aurora_N = DictGer.polarlicht_N ;
|
|
auspicious_A = DictGer.guenstig_A ;
|
|
austere_A = DictGer.schlicht_A ;
|
|
austerity_N = DictGer.einschraenkung_N ;
|
|
authentic_A = DictGer.authentisch_A ;
|
|
authentication_N = DictGer.authentifikation_N ;
|
|
author_N = DictGer.autor_N ;
|
|
authoritarian_A = DictGer.autoritaer_A ;
|
|
authority_N = DictGer.autoritaet_N ;
|
|
authorize_V2 = P.dirV2 (DictGer.autorisieren_V) ;
|
|
autistic_A = DictGer.autistisch_A ;
|
|
autobiographical_A = DictGer.autobiografisch_A ;
|
|
autobiography_N = DictGer.autobiografie_N ;
|
|
autocracy_N = DictGer.autokratie_N ;
|
|
autocrat_N = DictGer.autokrat_N ;
|
|
autograph_N = DictGer.unterschrift_N ;
|
|
automatic_A = DictGer.automatisch_A ;
|
|
automation_N = DictGer.automatisierung_N ;
|
|
automobile_N = DictGer.automobil_N ;
|
|
autonomous_A = DictGer.autonom_A ;
|
|
autonomy_N = DictGer.autonomie__N ;
|
|
autopsy_N = DictGer.autopsie_N ;
|
|
autumn_N = DictGer.herbst_N ;
|
|
autumnal_A = DictGer.herbstlich_A ;
|
|
auxiliary_A = DictGer.subsidiaer_A ;
|
|
availability_N = DictGer.verfuegbarkeit_N ;
|
|
available_A = DictGer.disponibel_A ;
|
|
avalanche_N = DictGer.lawine_N ;
|
|
avenue_N = DictGer.allee_N ;
|
|
aversion_N = DictGer.abneigung_N ;
|
|
avid_A = DictGer.eifrig_A ;
|
|
avocado_N = DictGer.avocado_N ;
|
|
avoid_V2 = P.dirV2 (DictGer.meiden_V) ;
|
|
await_V2 = P.dirV2 (DictGer.erwarten_V) ;
|
|
awake_A = DictGer.wach_A ;
|
|
awaken_V2 = P.dirV2 (DictGer.erwachen_V) ;
|
|
award_N = DictGer.preis_N ;
|
|
awesome_A = DictGer.grossartig_A ;
|
|
awful_A = DictGer.schrecklich_A ;
|
|
awl_N = DictGer.ahle_N ;
|
|
awning_N = DictGer.markise_N ;
|
|
axe_N = DictGer.axt_N ;
|
|
axiom_N = DictGer.axiom_N ;
|
|
axis_N = DictGer.achse_N ;
|
|
azalea_N = DictGer.azalee_N ;
|
|
baboon_N = DictGer.pavian_N ;
|
|
baby_N = LexiconGer.baby_N ;
|
|
babysitter_N = DictGer.babysitter_N ;
|
|
baccalaureate_N = DictGer.bakkalaureat_N ;
|
|
bachelor_N = DictGer.junggeselle_N ;
|
|
bacillus_N = DictGer.bazillus_N ;
|
|
back_N = LexiconGer.back_N ;
|
|
backbone_N = DictGer.rueckgrat_N ;
|
|
backdoor_N = DictGer.hintertuer_N ;
|
|
background_N = DictGer.hintergrund_N ;
|
|
backroom_N = DictGer.hinterzimmer_N ;
|
|
backside_N = DictGer.gesaess_N ;
|
|
bacon_N = DictGer.speck_N ;
|
|
bacteriologist_N = DictGer.bakteriologe_N ;
|
|
bacterium_N = DictGer.bakterie_N ;
|
|
bad_A = LexiconGer.bad_A ;
|
|
badge_N = DictGer.abzeichen_N ;
|
|
badger_N = DictGer.dachs_N ;
|
|
badminton_N = DictGer.federball_N ;
|
|
bag_N = DictGer.beutel_N ;
|
|
bagatelle_N = DictGer.bagatelle_N ;
|
|
baggage_N = DictGer.ballast_N ;
|
|
bail_N = DictGer.kaution_N ;
|
|
bait_N = DictGer.koeder_N ;
|
|
bake_V = DictGer.backen_3_V ;
|
|
bake_V2 = P.dirV2 (DictGer.backen_3_V) ;
|
|
baker_N = DictGer.baecker_N ;
|
|
bakery_N = DictGer.baeckerei_N ;
|
|
baksheesh_N = DictGer.bakschisch_N ;
|
|
balaclava_N = DictGer.sturmhaube_N ;
|
|
balance_N = DictGer.balance_N ;
|
|
bald_A = DictGer.glatzkoepfig_A ;
|
|
baldness_N = DictGer.glatze_N ;
|
|
ball_N = DictGer.ball_N ;
|
|
ballad_N = DictGer.ballade_N ;
|
|
ballast_N = DictGer.ballast_N ;
|
|
ballerina_N = DictGer.ballerina_N ;
|
|
ballet_N = DictGer.ballett_N ;
|
|
ballroom_N = DictGer.ballsaal_N ;
|
|
balmy_A = DictGer.lindernd_A ;
|
|
baloney_N = DictGer.kaese_N ;
|
|
balsam_N = DictGer.balsam_N ;
|
|
balustrade_N = DictGer.balustrade_N ;
|
|
bamboo_N = DictGer.bambus_N ;
|
|
bamboozle_V2 = P.dirV2 (DictGer.beschwindeln_V) ;
|
|
ban_V2 = P.dirV2 (DictGer.verbieten_V) ;
|
|
banal_A = DictGer.banal_A ;
|
|
banality_N = DictGer.banalitaet_N ;
|
|
banana_N = DictGer.banane_N ;
|
|
band_N = DictGer.bande_N ;
|
|
bandage_N = DictGer.verband_N ;
|
|
bandit_N = DictGer.bandit_N ;
|
|
bane_N = DictGer.verderben_N ;
|
|
bang_N = DictGer.hieb_N ;
|
|
banish_V2 = P.dirV2 (DictGer.verbannen_V) ;
|
|
banister_N = DictGer.gelaender_N ;
|
|
banjo_N = DictGer.banjo_N ;
|
|
bank_N = LexiconGer.bank_N ;
|
|
banker_N = DictGer.bankier_N ;
|
|
banknote_N = DictGer.banknote_N ;
|
|
bankrupt_A = DictGer.bankrott_A ;
|
|
bankruptcy_N = DictGer.bankrott_N ;
|
|
banner_N = DictGer.banner_N ;
|
|
banquet_N = DictGer.bankett_N ;
|
|
banshee_N = DictGer.banshee_N ;
|
|
baobab_N = DictGer.affenbrotbaum_N ;
|
|
baptism_N = DictGer.taufe_N ;
|
|
baptize_V2 = P.dirV2 (DictGer.taufen_V) ;
|
|
bar_N = DictGer.balken_N ;
|
|
barbarism_N = DictGer.barbarei_N ;
|
|
barbecue_N = DictGer.grill_N ;
|
|
barbel_N = DictGer.barbe_N ;
|
|
barber_N = DictGer.friseur_N ;
|
|
bard_N = DictGer.barde_N ;
|
|
bare_A = DictGer.bar_A ;
|
|
bareheaded_A = DictGer.barhaeuptig_A ;
|
|
bark_N = LexiconGer.bark_N ;
|
|
barley_N = DictGer.gerste_N ;
|
|
barn_N = DictGer.scheune_N ;
|
|
barometer_N = DictGer.barometer_N ;
|
|
baron_N = DictGer.baron_N ;
|
|
barrel_N = DictGer.fass_N ;
|
|
barren_A = DictGer.steril_A ;
|
|
barricade_N = DictGer.barrikade_N ;
|
|
barrier_N = DictGer.barriere_N ;
|
|
barrow_N = DictGer.borg_N ;
|
|
bartender_N = DictGer.barmann_N ;
|
|
base_N = DictGer.base_N ;
|
|
baseball_N = DictGer.baseball_N ;
|
|
basement_N = DictGer.keller_N ;
|
|
basilica_N = DictGer.basilika_N ;
|
|
basin_N = DictGer.becken_N ;
|
|
basis_N = DictGer.basis_N ;
|
|
basket_N = DictGer.korb_N ;
|
|
basketball_N = DictGer.basketball_N ;
|
|
bass_A = DictGer.bass_A ;
|
|
bassoon_N = DictGer.fagott_N ;
|
|
bastard_N = DictGer.arsch_N ;
|
|
bastion_N = DictGer.bastion_N ;
|
|
bat_N = DictGer.fledermaus_N ;
|
|
bath_N = DictGer.bad_N ;
|
|
bather_N = DictGer.schwimmer_N ;
|
|
bathrobe_N = DictGer.bademantel_N ;
|
|
bathroom_N = DictGer.bad_N ;
|
|
bathtub_N = DictGer.badewanne_N ;
|
|
baton_N = DictGer.taktstock_N ;
|
|
battalion_N = DictGer.bataillon_N ;
|
|
batter_V = DictGer.panieren_V ;
|
|
batter_V2 = P.dirV2 (DictGer.panieren_V) ;
|
|
battery_N = DictGer.batterie_N ;
|
|
battlefield_N = DictGer.schlachtfeld_N ;
|
|
bauble_N = DictGer.christbaumkugel_N ;
|
|
bay_N = DictGer.bucht_N ;
|
|
bayonet_N = DictGer.bajonett_N ;
|
|
bazaar_N = DictGer.basar_N ;
|
|
beach_N = DictGer.strand_N ;
|
|
bead_N = DictGer.perle_N ;
|
|
beak_N = DictGer.schnabel_N ;
|
|
beaker_N = DictGer.becherglas_N ;
|
|
beam_N = DictGer.balken_N ;
|
|
bean_N = DictGer.bohne_N ;
|
|
bear_N = DictGer.baer_N ;
|
|
bearable_A = DictGer.ertraeglich_A ;
|
|
beard_N = DictGer.bart_N ;
|
|
beast_N = DictGer.bestie_N ;
|
|
beater_N = DictGer.quirl_N ;
|
|
beautiful_A = LexiconGer.beautiful_A ;
|
|
beauty_N = DictGer.schoenheit_N ;
|
|
beaver_N = DictGer.biber_N ;
|
|
beckon_V = DictGer.winken_1_V ;
|
|
beckon_V2 = P.dirV2 (DictGer.winken_1_V) ;
|
|
become_V = DictGer.stehen_6_V ;
|
|
become_V2 = P.dirV2 (DictGer.stehen_6_V) ;
|
|
bed_N = DictGer.bank_N ;
|
|
bedbug_N = DictGer.wanze_N ;
|
|
bedouin_N = DictGer.beduine_N ;
|
|
bedroom_N = DictGer.schlafzimmer_N ;
|
|
bedsore_N = DictGer.dekubitus_N ;
|
|
bee_N = DictGer.biene_N ;
|
|
beech_N = DictGer.buche_N ;
|
|
beefy_A = DictGer.fleischig_A ;
|
|
beehive_N = DictGer.bienenkorb_N ;
|
|
beer_N = LexiconGer.beer_N ;
|
|
beet_N = DictGer.ruebe_N ;
|
|
beetle_N = DictGer.kaefer_N ;
|
|
befall_V = DictGer.werden_V ;
|
|
befall_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
beget_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
beggar_N = DictGer.bettler_N ;
|
|
begin_V = DictGer.beginnen_V ;
|
|
begin_V2 = P.dirV2 (DictGer.beginnen_V) ;
|
|
beginner_N = DictGer.anfaenger_N ;
|
|
beginning_N = DictGer.anfang_N ;
|
|
begonia_N = DictGer.begonie_N ;
|
|
beguile_V2 = P.dirV2 (DictGer.betoeren_V) ;
|
|
behead_V2 = P.dirV2 (DictGer.enthaupten_V) ;
|
|
behest_N = DictGer.befehl_N ;
|
|
behold_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
beholder_N = DictGer.beobachter_N ;
|
|
belated_A = DictGer.saeumig_A ;
|
|
belay_V2 = P.dirV2 (DictGer.beenden_V) ;
|
|
belch_V = DictGer.ruelpsen_V ;
|
|
belch_V2 = P.dirV2 (DictGer.ruelpsen_V) ;
|
|
beleaguer_V2 = P.dirV2 (DictGer.bedraengen_V) ;
|
|
belie_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
believable_A = DictGer.glaubhaft_A ;
|
|
believe_V = DictGer.glauben_V ;
|
|
believe_V2 = P.dirV2 (DictGer.glauben_V) ;
|
|
believer_N = DictGer.glaeubiger_N ;
|
|
belittle_V2 = P.dirV2 (DictGer.schmaelern_V) ;
|
|
bell_N = DictGer.glocke_N ;
|
|
bellicose_A = DictGer.kriegerisch_A ;
|
|
belly_N = LexiconGer.belly_N ;
|
|
belt_N = DictGer.gurt_N ;
|
|
bench_N = DictGer.bank_N ;
|
|
bend_V = DictGer.beugen_V ;
|
|
bend_V2 = P.dirV2 (DictGer.beugen_V) ;
|
|
beneficent_A = DictGer.gnaedig_A ;
|
|
beneficiary_N = DictGer.nutzniesser_N ;
|
|
benefit_N = DictGer.leistung_N ;
|
|
benign_A = DictGer.freundlich_A ;
|
|
benison_N = DictGer.segen_N ;
|
|
benzene_N = DictGer.benzol_N ;
|
|
benzine_N = DictGer.benzin_N ;
|
|
bequeath_V2 = P.dirV2 (DictGer.hinterlassen_V) ;
|
|
berate_V2 = P.dirV2 (DictGer.beschimpfen_V) ;
|
|
beret_N = DictGer.baskenmuetze_N ;
|
|
berry_N = DictGer.beere_N ;
|
|
beseech_V2 = P.dirV2 (DictGer.ersuchen_V) ;
|
|
beseem_V2 = P.dirV2 (DictGer.ziemen_V) ;
|
|
besiege_V2 = P.dirV2 (DictGer.belagern_V) ;
|
|
besmirch_V2 = P.dirV2 (DictGer.beschmutzen_V) ;
|
|
bespeak_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
bestial_A = DictGer.tierisch_A ;
|
|
bestow_V2 = P.dirV2 (DictGer.schenken_1_V) ;
|
|
bestride_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
bet_N = DictGer.wette_N ;
|
|
betake_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
bethink_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
betray_V2 = P.dirV2 (DictGer.verraten_V) ;
|
|
betrayer_N = DictGer.verraeter_N ;
|
|
beverage_N = DictGer.getraenk_N ;
|
|
bewail_V2 = P.dirV2 (DictGer.beklagen_V) ;
|
|
bib_N = DictGer.latz_N ;
|
|
bible_N = DictGer.bibel_N ;
|
|
biblical_A = DictGer.biblisch_A ;
|
|
bibliography_N = DictGer.bibliographie_N ;
|
|
bicycle_N = DictGer.fahrrad_N ;
|
|
bid_V = DictGer.bieten_2_V ;
|
|
bid_V2 = P.dirV2 (DictGer.bieten_2_V) ;
|
|
bidet_N = DictGer.bidet_N ;
|
|
bier_N = DictGer.bahre_N ;
|
|
bifurcation_N = DictGer.bifurkation_N ;
|
|
big_A = LexiconGer.big_A ;
|
|
bight_N = DictGer.bucht_N ;
|
|
bigot_N = DictGer.fanatiker_N ;
|
|
bigoted_A = DictGer.bigott_A ;
|
|
bike_N = LexiconGer.bike_N ;
|
|
bikini_N = DictGer.bikini_N ;
|
|
bilateral_A = DictGer.bilateral_A ;
|
|
bilberry_N = DictGer.blaubeere_N ;
|
|
bile_N = DictGer.galle_N ;
|
|
bilge_N = DictGer.bilge_N ;
|
|
bilingual_A = DictGer.bilingual_A ;
|
|
bill_N = DictGer.geldschein_N ;
|
|
billow_N = DictGer.woge_N ;
|
|
binary_A = DictGer.binaer_A ;
|
|
bindweed_N = DictGer.winde_N ;
|
|
biographical_A = DictGer.biografisch_A ;
|
|
biography_N = DictGer.biografie_N ;
|
|
biological_A = DictGer.biologisch_A ;
|
|
biologist_N = DictGer.biologe_N ;
|
|
biplane_N = DictGer.doppeldecker_N ;
|
|
birch_N = DictGer.birke_N ;
|
|
bird_N = LexiconGer.bird_N ;
|
|
birth_N = DictGer.geburt_N ;
|
|
birthday_N = DictGer.geburtsdatum_N ;
|
|
birthplace_N = DictGer.geburtsort_N ;
|
|
bisexual_A = DictGer.bisexuell_A ;
|
|
bishop_N = DictGer.bischof_N ;
|
|
bishopric_N = DictGer.bistum_N ;
|
|
bison_N = DictGer.bison_N ;
|
|
bit_N = DictGer.bit_N ;
|
|
bitch_N = DictGer.fuechsin_N ;
|
|
bite_V = DictGer.beissen_4_V ;
|
|
bite_V2 = LexiconGer.bite_V2 ;
|
|
bitter_A = DictGer.arg_A ;
|
|
bizarre_A = DictGer.bizarr_A ;
|
|
black_A = LexiconGer.black_A ;
|
|
blackamoor_N = DictGer.mohr_N ;
|
|
blackberry_N = DictGer.brombeere_N ;
|
|
blackbird_N = DictGer.amsel_N ;
|
|
blackboard_N = DictGer.tafel_N ;
|
|
blackmail_N = DictGer.erpressung_N ;
|
|
blackmailer_N = DictGer.erpresser_N ;
|
|
blackout_N = DictGer.filmriss_N ;
|
|
blacksmith_N = DictGer.schmied_N ;
|
|
blackthorn_N = DictGer.schlehe_N ;
|
|
blade_N = DictGer.blatt_N ;
|
|
blame_N = DictGer.schuld_N ;
|
|
bland_A = DictGer.fad_A ;
|
|
blank_A = DictGer.ausdruckslos_A ;
|
|
blanket_N = DictGer.decke_N ;
|
|
blasphemy_N = DictGer.blasphemie_N ;
|
|
blatant_A = DictGer.eklatant_A ;
|
|
bleach_N = DictGer.bleiche_N ;
|
|
bleak_A = DictGer.farblos_A ;
|
|
bleed_V = DictGer.bluten_V ;
|
|
bleed_V2 = P.dirV2 (DictGer.bluten_V) ;
|
|
blemish_N = DictGer.makel_N ;
|
|
bless_V2 = P.dirV2 (DictGer.benedeien_V) ;
|
|
blessing_N = DictGer.segen_N ;
|
|
blink_V = DictGer.blinken_V ;
|
|
blink_V2 = P.dirV2 (DictGer.blinken_V) ;
|
|
blister_N = DictGer.blase_N ;
|
|
blizzard_N = DictGer.schneesturm_N ;
|
|
block_N = DictGer.klotz_N ;
|
|
blockade_N = DictGer.blockade_N ;
|
|
blockbuster_N = DictGer.blockbuster_N ;
|
|
blockhead_N = DictGer.dummkopf_N ;
|
|
blockhouse_N = DictGer.blockhaus_N ;
|
|
bloke_N = DictGer.kerl_N ;
|
|
blond_N = DictGer.blondine_N ;
|
|
blonde_N = DictGer.blondine_N ;
|
|
blood_N = LexiconGer.blood_N ;
|
|
bloodhound_N = DictGer.detektiv_N ;
|
|
bloodless_A = DictGer.bleich_A ;
|
|
bloodthirsty_A = DictGer.blutruenstig_A ;
|
|
bloody_A = DictGer.blutig_A ;
|
|
blossom_N = DictGer.bluete_N ;
|
|
blot_N = DictGer.fleck_N ;
|
|
blouse_N = DictGer.bluse_N ;
|
|
blow_V = LexiconGer.blow_V ;
|
|
blow_V2 = P.dirV2 (DictGer.blasen_8_V) ;
|
|
blowfly_N = DictGer.aasfliege_N ;
|
|
blowhole_N = DictGer.lunker_N ;
|
|
bludgeon_N = DictGer.knueppel_N ;
|
|
blue_A = LexiconGer.blue_A ;
|
|
blueprint_N = DictGer.blaupause_N ;
|
|
bluish_A = DictGer.blaeulich_A ;
|
|
blunder_N = DictGer.patzer_N ;
|
|
boar_N = DictGer.eber_N ;
|
|
board_N = DictGer.brett_N ;
|
|
boat_N = LexiconGer.boat_N ;
|
|
boatswain_N = DictGer.bootsmann_N ;
|
|
body_N = DictGer.karosserie_N ;
|
|
bodyguard_N = DictGer.bodyguard_N ;
|
|
bog_N = DictGer.hochmoor_N ;
|
|
bogey_N = DictGer.popel_N ;
|
|
bogus_A = DictGer.falsch_A ;
|
|
boil_N = DictGer.furunkel_N ;
|
|
boiler_N = DictGer.boiler_N ;
|
|
bollard_N = DictGer.poller_N ;
|
|
bollock_N = DictGer.hoden_N ;
|
|
bolt_N = DictGer.ballen_N ;
|
|
bomb_N = DictGer.bombe_N ;
|
|
bombardment_N = DictGer.bombardement_N ;
|
|
bomber_N = DictGer.bomber_N ;
|
|
bombshell_N = DictGer.bombe_N ;
|
|
bondage_N = DictGer.pflicht_N ;
|
|
bone_N = LexiconGer.bone_N ;
|
|
boner_N = DictGer.latte_N ;
|
|
bonkers_A = DictGer.beknackt_A ;
|
|
bonnet_N = DictGer.haube_N ;
|
|
bonus_N = DictGer.praemie_N ;
|
|
bony_A = DictGer.graetig_A ;
|
|
boo_N = DictGer.buhruf_N ;
|
|
booby_N = DictGer.depp_N ;
|
|
book_N = LexiconGer.book_N ;
|
|
book_V2 = P.dirV2 (DictGer.bestrafen_V) ;
|
|
bookcase_N = DictGer.buecherregal_N ;
|
|
booklet_N = DictGer.broschuere_N ;
|
|
bookmark_N = DictGer.lesezeichen_N ;
|
|
bookseller_N = DictGer.buchhaendler_N ;
|
|
bookshop_N = DictGer.buchhandlung_N ;
|
|
bookworm_N = DictGer.buecherwurm_N ;
|
|
boom_V = DictGer.bluehen_9_V ;
|
|
boom_V2 = P.dirV2 (DictGer.bluehen_9_V) ;
|
|
boon_N = DictGer.segen_N ;
|
|
boot_N = LexiconGer.boot_N ;
|
|
booze_N = DictGer.schnaps_N ;
|
|
border_N = DictGer.rand_N ;
|
|
bore_V = DictGer.bohren_V ;
|
|
bore_V2 = P.dirV2 (DictGer.bohren_V) ;
|
|
borer_N = DictGer.bohrmaschine_N ;
|
|
borough_N = DictGer.bezirk_N ;
|
|
borrow_V = DictGer.borgen_V ;
|
|
borrow_V2 = P.dirV2 (DictGer.borgen_V) ;
|
|
borrower_N = DictGer.kreditnehmer_N ;
|
|
bosom_N = DictGer.busen_N ;
|
|
boss_N = LexiconGer.boss_N ;
|
|
botanical_A = DictGer.botanisch_A ;
|
|
botanist_N = DictGer.botaniker_N ;
|
|
bother_V = DictGer.belaestigen_V ;
|
|
bother_V2 = P.dirV2 (DictGer.belaestigen_V) ;
|
|
bottle_N = DictGer.flasche_N ;
|
|
bottleneck_N = DictGer.engpass_N ;
|
|
bottom_N = DictGer.boden_N ;
|
|
bough_N = DictGer.ast_N ;
|
|
bouillon_N = DictGer.bouillon_N ;
|
|
boulevard_N = DictGer.boulevard_N ;
|
|
bounce_V = DictGer.platzen_V ;
|
|
bounce_V2 = P.dirV2 (DictGer.platzen_V) ;
|
|
boundary_N = DictGer.rand_N ;
|
|
bounty_N = DictGer.belohnung_N ;
|
|
bouquet_N = DictGer.blumenstrauss_N ;
|
|
bourbon_N = DictGer.bourbon_N ;
|
|
bourgeois_A = DictGer.spiessig_A ;
|
|
bourgeoisie_N = DictGer.bourgeoisie_N ;
|
|
bow_N = DictGer.schleife_N ;
|
|
bowdlerize_V2 = P.dirV2 (DictGer.zensieren_V) ;
|
|
bowel_N = DictGer.darm_N ;
|
|
bowl_N = DictGer.schale_N ;
|
|
box_N = DictGer.box_N ;
|
|
boy_N = LexiconGer.boy_N ;
|
|
boycott_V2 = P.dirV2 (DictGer.boykottieren_V) ;
|
|
boyfriend_N = DictGer.freund_N ;
|
|
bra_N = DictGer.buestenhalter_N ;
|
|
brace_N = DictGer.hosentraeger_N ;
|
|
bracelet_N = DictGer.armband_N ;
|
|
bracket_N = DictGer.klammer_N ;
|
|
brag_V = DictGer.prahlen_V ;
|
|
braggart_N = DictGer.angeber_N ;
|
|
brain_N = DictGer.gehirn_N ;
|
|
brainless_A = DictGer.einfaeltig_A ;
|
|
brake_N = DictGer.bremse_N ;
|
|
bramble_N = DictGer.brombeere_N ;
|
|
bran_N = DictGer.kleie_N ;
|
|
branch_N = DictGer.ast_N ;
|
|
brand_N = DictGer.brandmal_N ;
|
|
brandish_V2 = P.dirV2 (DictGer.schwingen_5_V) ;
|
|
brandy_N = DictGer.kognak_N ;
|
|
brash_A = DictGer.dreist_A ;
|
|
brass_N = DictGer.blech_N ;
|
|
brat_N = DictGer.balg_N ;
|
|
brave_A = DictGer.mutig_A ;
|
|
brawn_N = DictGer.suelze_N ;
|
|
bray_V2 = P.dirV2 (DictGer.iahen_V) ;
|
|
breach_N = DictGer.bresche_N ;
|
|
bread_N = LexiconGer.bread_N ;
|
|
breadcrumb_N = DictGer.brotkrume_N ;
|
|
breadth_N = DictGer.breite_N ;
|
|
break_V = DictGer.brechen_8_V ;
|
|
break_V2 = LexiconGer.break_V2 ;
|
|
breakdown_N = DictGer.panne_N ;
|
|
breakfast_N = DictGer.fruehstueck_N ;
|
|
breakwater_N = DictGer.buhne_N ;
|
|
breast_N = LexiconGer.breast_N ;
|
|
breaststroke_N = DictGer.brust_N ;
|
|
breath_N = DictGer.atem_N ;
|
|
breathe_V = LexiconGer.breathe_V ;
|
|
breathe_V2 = P.dirV2 (DictGer.atmen_1_V) ;
|
|
breed_V = DictGer.erzeugen_V ;
|
|
breed_V2 = P.dirV2 (DictGer.erzeugen_V) ;
|
|
breeder_N = DictGer.zuechter_N ;
|
|
breeze_N = DictGer.brise_N ;
|
|
breviary_N = DictGer.brevier_N ;
|
|
brew_V = DictGer.brauen_V ;
|
|
brew_V2 = P.dirV2 (DictGer.brauen_V) ;
|
|
brewery_N = DictGer.brauerei_N ;
|
|
bribe_N = DictGer.bestechung_N ;
|
|
bribery_N = DictGer.bestechung_N ;
|
|
brick_N = DictGer.backstein_N ;
|
|
bricklayer_N = DictGer.maurer_N ;
|
|
bride_N = DictGer.braut_N ;
|
|
bridge_N = DictGer.bruecke_N ;
|
|
brief_A = DictGer.kurz_A ;
|
|
brigade_N = DictGer.brigade_N ;
|
|
bright_A = DictGer.glaenzend_A ;
|
|
brighten_V = DictGer.schoenen_V ;
|
|
brighten_V2 = P.dirV2 (DictGer.schoenen_V) ;
|
|
brightness_N = DictGer.helligkeit_N ;
|
|
brilliant_A = DictGer.brillant_A ;
|
|
brim_N = DictGer.krempe_N ;
|
|
bring_V2 = P.dirV2 (DictGer.bringen_8_V) ;
|
|
brioche_N = DictGer.brioche_N ;
|
|
brisk_A = DictGer.anregend_A ;
|
|
brisket_N = DictGer.brust_N ;
|
|
brittle_A = DictGer.kuehl_A ;
|
|
broad_A = LexiconGer.broad_A ;
|
|
brochure_N = DictGer.broschuere_N ;
|
|
broke_A = DictGer.pleite_A ;
|
|
bromide_N = DictGer.bromid_N ;
|
|
bronchitis_N = DictGer.bronchitis_N ;
|
|
bronze_N = DictGer.bronze_N ;
|
|
broom_N = DictGer.besen_N ;
|
|
broomstick_N = DictGer.besenstiel_N ;
|
|
broth_N = DictGer.bruehe_N ;
|
|
brothel_N = DictGer.bordell_N ;
|
|
brotherly_A = DictGer.bruederlich_A ;
|
|
brouhaha_N = DictGer.aufruhr_N ;
|
|
brow_N = DictGer.augenbraue_N ;
|
|
brown_A = LexiconGer.brown_A ;
|
|
brownish_A = DictGer.braeunlich_A ;
|
|
browse_V = DictGer.blaettern_3_V ;
|
|
brush_N = DictGer.busch_N ;
|
|
brusque_A = DictGer.bruesk_A ;
|
|
brutal_A = DictGer.brutal_A ;
|
|
brutality_N = DictGer.brutalitaet_N ;
|
|
brutish_A = DictGer.brutal_A ;
|
|
bubble_N = DictGer.blase_N ;
|
|
buck_N = DictGer.bock_N ;
|
|
bucket_N = DictGer.eimer_N ;
|
|
bud_N = DictGer.knospe_N ;
|
|
buddy_N = DictGer.kollege_N ;
|
|
budgerigar_N = DictGer.wellensittich_N ;
|
|
budget_N = DictGer.budget_N ;
|
|
buffalo_N = DictGer.bison_N ;
|
|
buffer_N = DictGer.puffer_N ;
|
|
bug_N = DictGer.fehler_N ;
|
|
bugle_N = DictGer.buegelhorn_N ;
|
|
build_V = DictGer.bauen_0_V ;
|
|
build_V2 = P.dirV2 (DictGer.bauen_0_V) ;
|
|
building_N = DictGer.gebaeude_N ;
|
|
bulgarian_A = DictGer.bulgarisch_A ;
|
|
bulk_N = DictGer.grossteil_N ;
|
|
bull_N = DictGer.bulle_N ;
|
|
bulldog_N = DictGer.bulldogge_N ;
|
|
bulldozer_N = DictGer.planierraupe_N ;
|
|
bullet_N = DictGer.kugel_N ;
|
|
bulletin_N = DictGer.bulletin_N ;
|
|
bulletproof_A = DictGer.kugelsicher_A ;
|
|
bullfighter_N = DictGer.torero_N ;
|
|
bullfinch_N = DictGer.dompfaff_N ;
|
|
bully_N = DictGer.rabauke_N ;
|
|
bum_N = DictGer.penner_N ;
|
|
bumblebee_N = DictGer.hummel_N ;
|
|
bumpy_A = DictGer.holprig_A ;
|
|
bun_N = DictGer.broetchen_N ;
|
|
bundle_N = DictGer.buendel_N ;
|
|
bungalow_N = DictGer.bungalow_N ;
|
|
bunk_N = DictGer.koje_N ;
|
|
bunker_N = DictGer.bunker_N ;
|
|
bunny_N = DictGer.hase_N ;
|
|
buoy_N = DictGer.boje_N ;
|
|
buoyancy_N = DictGer.auftrieb_N ;
|
|
buoyant_A = DictGer.heiter_A ;
|
|
burden_N = DictGer.belastung_N ;
|
|
burdock_N = DictGer.klette_N ;
|
|
bureau_N = DictGer.buero_N ;
|
|
bureaucracy_N = DictGer.buerokratie_N ;
|
|
bureaucrat_N = DictGer.buerokrat_N ;
|
|
burette_N = DictGer.buerette_N ;
|
|
burglar_N = DictGer.dieb_N ;
|
|
burglary_N = DictGer.einbruch_N ;
|
|
burgomaster_N = DictGer.buergermeister_N ;
|
|
burial_N = DictGer.begraebnis_N ;
|
|
burly_A = DictGer.kraeftig_A ;
|
|
burn_N = DictGer.bach_N ;
|
|
burn_V = LexiconGer.burn_V ;
|
|
burner_N = DictGer.brenner_N ;
|
|
burr_N = DictGer.grat_N ;
|
|
bury_V = DictGer.beerdigen_V ;
|
|
bury_V2 = P.dirV2 (DictGer.beerdigen_V) ;
|
|
bus_N = DictGer.bus_N ;
|
|
bush_N = DictGer.busch_N ;
|
|
bushel_N = DictGer.scheffel_N ;
|
|
business_N = DictGer.geschaeft_N ;
|
|
businesslike_A = DictGer.sachbezogen_A ;
|
|
bust_N = DictGer.bueste_N ;
|
|
busy_A = DictGer.beschaeftigt_A ;
|
|
butcher_N = DictGer.fleischer_N ;
|
|
butler_N = DictGer.butler_N ;
|
|
butt_N = DictGer.arsch_N ;
|
|
butter_N = LexiconGer.butter_N ;
|
|
buttercup_N = DictGer.hahnenfuss_N ;
|
|
butterfly_N = DictGer.delfin_N ;
|
|
buttock_N = DictGer.backe_N ;
|
|
button_N = DictGer.knopf_N ;
|
|
buttonhole_N = DictGer.knopfloch_N ;
|
|
buttress_N = DictGer.stuetze_N ;
|
|
buxom_A = DictGer.drall_A ;
|
|
buy_V = DictGer.kaufen_7_V ;
|
|
buy_V2 = LexiconGer.buy_V2 ;
|
|
buyer_N = DictGer.kaeufer_N ;
|
|
buzz_N = DictGer.anruf_N ;
|
|
buzzard_N = DictGer.bussard_N ;
|
|
bylaw_N = DictGer.satzung_N ;
|
|
bypass_N = DictGer.bypass_N ;
|
|
byproduct_N = DictGer.nebenprodukt_N ;
|
|
cab_N = DictGer.taxi_N ;
|
|
cabaret_N = DictGer.kabarett_N ;
|
|
cabbage_N = DictGer.kohl_N ;
|
|
cabin_N = DictGer.kabine_N ;
|
|
cabinet_N = DictGer.kabinett_N ;
|
|
cable_N = DictGer.kabel_N ;
|
|
cacao_N = DictGer.kakaobaum_N ;
|
|
cache_N = DictGer.cache_N ;
|
|
cacophony_N = DictGer.kakophonie_N ;
|
|
cadaver_N = DictGer.kadaver_N ;
|
|
cadence_N = DictGer.kadenz_N ;
|
|
cadenza_N = DictGer.kadenz_N ;
|
|
cadre_N = DictGer.kader_N ;
|
|
caesura_N = DictGer.zaesur_N ;
|
|
cafe_N = DictGer.cafe_N ;
|
|
cafeteria_N = DictGer.kantine_N ;
|
|
cage_N = DictGer.kaefig_N ;
|
|
cake_N = DictGer.kuchen_N ;
|
|
calamity_N = DictGer.kalamitaet_N ;
|
|
calcium_N = DictGer.calcium_N ;
|
|
calculate_V = DictGer.berechnen_V ;
|
|
calculate_V2 = P.dirV2 (DictGer.berechnen_V) ;
|
|
calculator_N = DictGer.rechner_N ;
|
|
calendar_N = DictGer.kalender_N ;
|
|
calf_N = DictGer.kalb_N ;
|
|
calibrate_V2 = P.dirV2 (DictGer.kalibrieren_V) ;
|
|
calibre_N = DictGer.bohrung_N ;
|
|
caliph_N = DictGer.kalif_N ;
|
|
caliphate_N = DictGer.kalifat_N ;
|
|
call_N = DictGer.anruf_N ;
|
|
callous_A = DictGer.schwielig_A ;
|
|
callow_A = DictGer.kahl_A ;
|
|
calm_A = DictGer.ruhig_A ;
|
|
calorie_N = DictGer.kalorie_N ;
|
|
calumny_N = DictGer.rufmord_N ;
|
|
camel_N = DictGer.kamel_N ;
|
|
camellia_N = DictGer.kamelie_N ;
|
|
camembert_N = DictGer.camembert_N ;
|
|
camera_N = LexiconGer.camera_N ;
|
|
cameraman_N = DictGer.kamerafrau_N ;
|
|
camomile_N = DictGer.kamille_N ;
|
|
camouflage_N = DictGer.tarnung_N ;
|
|
campaign_N = DictGer.feldzug_N ;
|
|
camshaft_N = DictGer.nockenwelle_N ;
|
|
can_V2 = P.dirV2 (DictGer.duerfen_V) ;
|
|
canadian_N = DictGer.kanadier_N ;
|
|
canal_N = DictGer.kanal_N ;
|
|
canape_N = DictGer.kanapee_N ;
|
|
canard_N = DictGer.zeitungsente_N ;
|
|
canary_N = DictGer.kanarienvogel_N ;
|
|
cancel_V = DictGer.kuerzen_V ;
|
|
cancel_V2 = P.dirV2 (DictGer.kuerzen_V) ;
|
|
cancer_N = DictGer.krebs_N ;
|
|
candelabrum_N = DictGer.kandelaber_N ;
|
|
candidate_N = DictGer.kandidat_N ;
|
|
candle_N = DictGer.kerze_N ;
|
|
candlelight_N = DictGer.kerzenlicht_N ;
|
|
candlewick_N = DictGer.docht_N ;
|
|
cane_N = DictGer.rohr_N ;
|
|
cannibal_N = DictGer.kannibale_N ;
|
|
canoe_N = DictGer.kanu_N ;
|
|
canopy_N = DictGer.baldachin_N ;
|
|
cant_N = DictGer.fachsprache_N ;
|
|
canteen_N = DictGer.kantine_N ;
|
|
cantilever_N = DictGer.auskragung_N ;
|
|
canton_N = DictGer.kanton_N ;
|
|
canvas_N = DictGer.leinen_N ;
|
|
canyon_N = DictGer.klamm_N ;
|
|
cap_N = LexiconGer.cap_N ;
|
|
capable_A = DictGer.faehig_A ;
|
|
capacity_N = DictGer.kapazitaet_N ;
|
|
cape_N = DictGer.kap_N ;
|
|
capital_N = DictGer.grossbuchstabe_N ;
|
|
capitulation_N = DictGer.kapitulation_N ;
|
|
capon_N = DictGer.kapaun_N ;
|
|
caprice_N = DictGer.laune_N ;
|
|
capricious_A = DictGer.kaprizioes_A ;
|
|
capsize_V = DictGer.kentern_V ;
|
|
capsize_V2 = P.dirV2 (DictGer.kentern_V) ;
|
|
capsule_N = DictGer.kapsel_N ;
|
|
captain_N = DictGer.kapitaen_N ;
|
|
caption_N = DictGer.legende_N ;
|
|
captivate_V2 = P.dirV2 (DictGer.bestechen_V) ;
|
|
captivity_N = DictGer.gefangenschaft_N ;
|
|
capture_N = DictGer.fang_N ;
|
|
car_N = LexiconGer.car_N ;
|
|
carafe_N = DictGer.karaffe_N ;
|
|
carat_N = DictGer.karat_N ;
|
|
caravan_N = DictGer.karawane_N ;
|
|
caravanserai_N = DictGer.karawanserei_N ;
|
|
caraway_N = DictGer.kuemmel_N ;
|
|
carbine_N = DictGer.karabiner_N ;
|
|
carbohydrate_N = DictGer.kohlenhydrat_N ;
|
|
carbon_N = DictGer.kohle_N ;
|
|
carbuncle_N = DictGer.karbunkel_N ;
|
|
card_N = DictGer.karte_N ;
|
|
cardboard_N = DictGer.pappe_N ;
|
|
cardigan_N = DictGer.strickjacke_N ;
|
|
cardinal_A = DictGer.grundsaetzlich_A ;
|
|
care_N = DictGer.pflege_N ;
|
|
career_N = DictGer.karriere_N ;
|
|
carefree_A = DictGer.sorglos_A ;
|
|
careful_A = DictGer.behutsam_A ;
|
|
careless_A = DictGer.sorglos_A ;
|
|
cargo_N = DictGer.fracht_N ;
|
|
caricature_N = DictGer.karikatur_N ;
|
|
caricaturist_N = DictGer.karikaturist_N ;
|
|
carnage_N = DictGer.massaker_N ;
|
|
carnation_N = DictGer.nelke_N ;
|
|
carnivore_N = DictGer.fleischfresser_N ;
|
|
carp_N = DictGer.karpfen_N ;
|
|
carpenter_N = DictGer.schreiner_N ;
|
|
carpet_N = LexiconGer.carpet_N ;
|
|
carriage_N = DictGer.gang_N ;
|
|
carrier_N = DictGer.brieftaube_N ;
|
|
carrion_N = DictGer.kadaver_N ;
|
|
carrot_N = DictGer.karotte_N ;
|
|
carry_V = DictGer.fuehren_3_V ;
|
|
carry_V2 = P.dirV2 (DictGer.fuehren_3_V) ;
|
|
cart_N = DictGer.karren_N ;
|
|
cartel_N = DictGer.kartell_N ;
|
|
carter_N = DictGer.wagner_N ;
|
|
cartilage_N = DictGer.knorpel_N ;
|
|
cartoon_N = DictGer.karikatur_N ;
|
|
cartridge_N = DictGer.patrone_N ;
|
|
carve_V = DictGer.schneiden_6_V ;
|
|
carve_V2 = P.dirV2 (DictGer.schneiden_6_V) ;
|
|
carver_N = DictGer.schnitzer_N ;
|
|
cascade_N = DictGer.kaskade_N ;
|
|
case_N = DictGer.behaelter_N ;
|
|
cashier_N = DictGer.kassierer_N ;
|
|
casino_N = DictGer.kasino_N ;
|
|
casket_N = DictGer.kaestchen_N ;
|
|
casserole_N = DictGer.auflauf_N ;
|
|
cassette_N = DictGer.kassette_N ;
|
|
cassock_N = DictGer.soutane_N ;
|
|
cast_V = DictGer.giessen_V ;
|
|
cast_V2 = P.dirV2 (DictGer.giessen_V) ;
|
|
castigation_N = DictGer.zuechtigung_N ;
|
|
castle_N = DictGer.festung_N ;
|
|
castrate_V2 = P.dirV2 (DictGer.kastrieren_V) ;
|
|
casual_A = DictGer.gelegentlich_A ;
|
|
casualty_N = DictGer.opfer_N ;
|
|
cat_N = LexiconGer.cat_N ;
|
|
cataclysm_N = DictGer.kataklysmus_N ;
|
|
catafalque_N = DictGer.katafalk_N ;
|
|
catalogue_N = DictGer.katalog_N ;
|
|
catalysis_N = DictGer.katalyse_N ;
|
|
catalyst_N = DictGer.katalysator_N ;
|
|
catamaran_N = DictGer.katamaran_N ;
|
|
catapult_N = DictGer.katapult_N ;
|
|
cataract_N = DictGer.katarakt_N ;
|
|
catastrophe_N = DictGer.katastrophe_N ;
|
|
catastrophic_A = DictGer.katastrophal_A ;
|
|
catch_N = DictGer.fang_N ;
|
|
catchword_N = DictGer.kustos_N ;
|
|
catchy_A = DictGer.packend_A ;
|
|
catechism_N = DictGer.katechismus_N ;
|
|
categorize_V2 = P.dirV2 (DictGer.kategorisieren_V) ;
|
|
category_N = DictGer.kategorie_N ;
|
|
caterpillar_N = DictGer.raupe_N ;
|
|
catfish_N = DictGer.wels_N ;
|
|
cathedral_N = DictGer.dom_N ;
|
|
cathode_N = DictGer.kathode_N ;
|
|
catkin_N = DictGer.kaetzchen_N ;
|
|
cattish_A = DictGer.boshaft_A ;
|
|
catty_A = DictGer.boshaft_A ;
|
|
catwalk_N = DictGer.laufsteg_N ;
|
|
cauldron_N = DictGer.kessel_N ;
|
|
causality_N = DictGer.kausalitaet_N ;
|
|
causation_N = DictGer.ursache_N ;
|
|
cause_N = DictGer.sache_N ;
|
|
causeway_N = DictGer.bahndamm_N ;
|
|
caution_N = DictGer.achtsamkeit_N ;
|
|
cautious_A = DictGer.behutsam_A ;
|
|
cavalry_N = DictGer.kavallerie_N ;
|
|
cave_N = DictGer.hoehle_N ;
|
|
caveat_N = DictGer.ausnahme_N ;
|
|
caviar_N = DictGer.kaviar_N ;
|
|
cavil_V = DictGer.noergeln_V ;
|
|
cedar_N = DictGer.zeder_N ;
|
|
cedilla_N = DictGer.cedille_N ;
|
|
ceiling_N = LexiconGer.ceiling_N ;
|
|
celebrate_V2 = P.dirV2 (DictGer.feiern_7_V) ;
|
|
celebration_N = DictGer.feier_N ;
|
|
celebrity_N = DictGer.beruehmtheit_N ;
|
|
cell_N = DictGer.handy_N ;
|
|
cellar_N = DictGer.keller_N ;
|
|
cello_N = DictGer.cello_N ;
|
|
cellulose_N = DictGer.zellulose_N ;
|
|
cement_N = DictGer.zement_N ;
|
|
censorship_N = DictGer.zensur_N ;
|
|
census_N = DictGer.zensus_N ;
|
|
centaur_N = DictGer.kentaur_N ;
|
|
centipede_N = DictGer.tausendfuesser_N ;
|
|
central_A = DictGer.zentral_A ;
|
|
centrifuge_N = DictGer.zentrifuge_N ;
|
|
century_N = DictGer.jahrhundert_N ;
|
|
ceramic_A = DictGer.keramisch_A ;
|
|
cerebral_A = DictGer.zerebral_A ;
|
|
ceremony_N = DictGer.zeremonie_N ;
|
|
certain_A = DictGer.bestimmt_A ;
|
|
certainty_N = DictGer.sicherheit_N ;
|
|
certificate_N = DictGer.zertifikat_N ;
|
|
certification_N = DictGer.zertifizierung_N ;
|
|
certify_V = DictGer.zertifizieren_V ;
|
|
certify_V2 = P.dirV2 (DictGer.zertifizieren_V) ;
|
|
chaffinch_N = DictGer.buchfink_N ;
|
|
chain_N = DictGer.kette_N ;
|
|
chair_N = LexiconGer.chair_N ;
|
|
chairman_N = DictGer.vorsitzende_N ;
|
|
chalice_N = DictGer.kelch_N ;
|
|
chalk_N = DictGer.kreide_N ;
|
|
challenge_N = DictGer.herausforderung_N ;
|
|
chamber_N = DictGer.gemach_N ;
|
|
chambermaid_N = DictGer.stubenmaedchen_N ;
|
|
chameleon_N = DictGer.chamaeleon_N ;
|
|
champagne_N = DictGer.champagner_N ;
|
|
champion_N = DictGer.gewinner_N ;
|
|
championship_N = DictGer.meisterschaft__N ;
|
|
chance_N = DictGer.chance_N ;
|
|
chancellor_N = DictGer.kanzler_N ;
|
|
change_N = DictGer.veraenderung_N ;
|
|
channel_N = DictGer.kanal_N ;
|
|
chaotic_A = DictGer.chaotisch_A ;
|
|
chap_N = DictGer.kerl_N ;
|
|
chapel_N = DictGer.kapelle_N ;
|
|
chaplain_N = DictGer.kaplan_N ;
|
|
chapter_N = DictGer.abschnitt_N ;
|
|
char_N = DictGer.kohle_N ;
|
|
character_N = DictGer.buchstabe_N ;
|
|
characteristic_A = DictGer.charakteristisch_A ;
|
|
characterize_V2 = P.dirV2 (DictGer.charakterisieren_V) ;
|
|
charcoal_N = DictGer.holzkohle_N ;
|
|
chard_N = DictGer.mangold_N ;
|
|
charge_N = DictGer.entgelt_N ;
|
|
charger_N = DictGer.ladegeraet_N ;
|
|
charismatic_A = DictGer.charismatisch_A ;
|
|
charlatan_N = DictGer.scharlatan_N ;
|
|
charming_A = DictGer.charmant_A ;
|
|
chart_N = DictGer.karte_N ;
|
|
charter_N = DictGer.charta_N ;
|
|
charwoman_N = DictGer.putzfrau_N ;
|
|
chase_N = DictGer.jagd_N ;
|
|
chaser_N = DictGer.gewindeschneider_N ;
|
|
chasm_N = DictGer.abgrund_N ;
|
|
chassis_N = DictGer.chassis_N ;
|
|
chat_V = DictGer.chatten_V ;
|
|
chat_V2 = P.dirV2 (DictGer.chatten_V) ;
|
|
chateau_N = DictGer.chateau_0_N ;
|
|
chatty_A = DictGer.geschwaetzig_A ;
|
|
chauffeur_N = DictGer.chauffeur_N ;
|
|
chauvinism_N = DictGer.chauvinismus_N ;
|
|
cheat_V = DictGer.betruegen_V ;
|
|
cheat_V2 = P.dirV2 (DictGer.betruegen_V) ;
|
|
check_N = DictGer.karo_N ;
|
|
checkers_N = DictGer.dame_N ;
|
|
checklist_N = DictGer.checkliste_N ;
|
|
checkmate_N = DictGer.niederlage_N ;
|
|
cheek_N = DictGer.backe_N ;
|
|
cheekbone_N = DictGer.jochbein_N ;
|
|
cheeky_A = DictGer.frech_A ;
|
|
cheerful_A = DictGer.freundlich_A ;
|
|
cheerleader_N = DictGer.cheerleader_N ;
|
|
cheese_N = LexiconGer.cheese_N ;
|
|
cheesecake_N = DictGer.kaesekuchen_N ;
|
|
chemical_A = DictGer.chemisch_A ;
|
|
chemist_N = DictGer.chemiker_N ;
|
|
chemistry_N = DictGer.chemie_N ;
|
|
cheque_N = DictGer.scheck_N ;
|
|
cherish_V2 = P.dirV2 (DictGer.hegen_V) ;
|
|
cherry_N = DictGer.kirschbaum_N ;
|
|
chessboard_N = DictGer.schachbrett_N ;
|
|
chest_N = DictGer.brust_N ;
|
|
chestnut_N = DictGer.fuchs_N ;
|
|
chic_A = DictGer.chic_A ;
|
|
chicanery_N = DictGer.schikane_N ;
|
|
chick_N = DictGer.kueken_N ;
|
|
chicken_N = DictGer.feigling_N ;
|
|
chickpea_N = DictGer.kichererbse_N ;
|
|
chicory_N = DictGer.wegwarte_N ;
|
|
chide_V = DictGer.schelten_V ;
|
|
chide_V2 = P.dirV2 (DictGer.schelten_V) ;
|
|
chief_N = DictGer.boss_N ;
|
|
child_N = LexiconGer.child_N ;
|
|
childbirth_N = DictGer.geburt_N ;
|
|
childish_A = DictGer.kindisch_A ;
|
|
childless_A = DictGer.kinderlos_A ;
|
|
childlike_A = DictGer.kindlich_A ;
|
|
chill_N = DictGer.frost_N ;
|
|
chimera_N = DictGer.chimaere_N ;
|
|
chimney_N = DictGer.esse_N ;
|
|
chimpanzee_N = DictGer.schimpanse_N ;
|
|
chin_N = DictGer.kinn_N ;
|
|
chinchilla_N = DictGer.chinchilla_N ;
|
|
chip_N = DictGer.kartoffelchip_N ;
|
|
chipmunk_N = DictGer.streifenhoernchen_N ;
|
|
chiropractor_N = DictGer.chiropraktiker_N ;
|
|
chisel_N = DictGer.meissel_N ;
|
|
chivalrous_A = DictGer.ehrlich_A ;
|
|
chive_N = DictGer.schnittlauch_N ;
|
|
chloride_N = DictGer.chlorid_N ;
|
|
chlorine_N = DictGer.chlor_N ;
|
|
chocolate_N = DictGer.praline_N ;
|
|
choice_N = DictGer.auswahl_N ;
|
|
choose_V = DictGer.entscheiden_V ;
|
|
choose_V2 = P.dirV2 (DictGer.entscheiden_V) ;
|
|
choosy_A = DictGer.waehlerisch_A ;
|
|
chop_N = DictGer.hieb_N ;
|
|
chorale_N = DictGer.choral_N ;
|
|
chord_N = DictGer.akkord_N ;
|
|
choreography_N = DictGer.choreografie_N ;
|
|
chorus_N = DictGer.refrain_N ;
|
|
chowder_N = DictGer.fischsuppe_N ;
|
|
christen_V2 = P.dirV2 (DictGer.taufen_V) ;
|
|
chromosome_N = DictGer.chromosom_N ;
|
|
chronicle_N = DictGer.chronik_N ;
|
|
chronological_A = DictGer.chronologisch_A ;
|
|
chrysanthemum_N = DictGer.chrysantheme_N ;
|
|
chuck_N = DictGer.spannfutter_N ;
|
|
chump_N = DictGer.dummkopf_N ;
|
|
chunk_N = DictGer.stueck_N ;
|
|
church_N = LexiconGer.church_N ;
|
|
churchgoer_N = DictGer.kirchgaenger_N ;
|
|
churl_N = DictGer.kerl_N ;
|
|
churlish_A = DictGer.knauserig_A ;
|
|
chutney_N = DictGer.chutney_N ;
|
|
cider_N = DictGer.apfelwein_N ;
|
|
cigar_N = DictGer.zigarre_N ;
|
|
cigarette_N = DictGer.zigarette_N ;
|
|
cinch_N = DictGer.kinderspiel_N ;
|
|
cinema_N = DictGer.film_N ;
|
|
cinnamon_N = DictGer.zimt_N ;
|
|
cipher_N = DictGer.chiffre_N ;
|
|
circle_N = DictGer.kreis_N ;
|
|
circumcise_V2 = P.dirV2 (DictGer.beschneiden_V) ;
|
|
circumference_N = DictGer.umfang_N ;
|
|
circumspect_A = DictGer.vorsichtig_A ;
|
|
circumstance_N = DictGer.umstand_N ;
|
|
circus_N = DictGer.zirkus_N ;
|
|
cirrhosis_N = DictGer.zirrhose_N ;
|
|
cistern_N = DictGer.zisterne_N ;
|
|
citadel_N = DictGer.zitadelle_N ;
|
|
citation_N = DictGer.zitat_N ;
|
|
citizen_N = DictGer.buerger_N ;
|
|
citizenship_N = DictGer.staatsbuergerschaft_N ;
|
|
city_N = LexiconGer.city_N ;
|
|
civic_A = DictGer.buergerlich_A ;
|
|
civil_A = DictGer.buergerlich_A ;
|
|
civility_N = DictGer.anstand_N ;
|
|
civilization_N = DictGer.kultur_N ;
|
|
claim_N = DictGer.anspruch_N ;
|
|
clam_N = DictGer.muschel_N ;
|
|
clammy_A = DictGer.klamm_A ;
|
|
clamp_N = DictGer.klammer_N ;
|
|
clan_N = DictGer.sippe_N ;
|
|
clapper_N = DictGer.kloeppel_N ;
|
|
clarinet_N = DictGer.klarinette_N ;
|
|
clarinetist_N = DictGer.klarinettist_N ;
|
|
clarity_N = DictGer.klarheit_N ;
|
|
clasp_N = DictGer.griff_N ;
|
|
class_N = DictGer.classis_N ;
|
|
classic_A = DictGer.klassisch_A ;
|
|
classical_A = DictGer.klassisch_A ;
|
|
classification_N = DictGer.klassifikation_N ;
|
|
classmate_N = DictGer.klassenkamerad_N ;
|
|
classroom_N = DictGer.klassenzimmer_N ;
|
|
classy_A = DictGer.nobel_A ;
|
|
clause_N = DictGer.klausel_N ;
|
|
claustrophobia_N = DictGer.klaustrophobie_N ;
|
|
clavicle_N = DictGer.clavicula_N ;
|
|
claw_N = DictGer.klaue_N ;
|
|
clay_N = DictGer.asche_N ;
|
|
clean_A = LexiconGer.clean_A ;
|
|
cleanliness_N = DictGer.sauberkeit_N ;
|
|
clear_A = DictGer.durchsichtig_A ;
|
|
cleavage_N = DictGer.dekolletee_N ;
|
|
cleaver_N = DictGer.cleaver_N ;
|
|
clef_N = DictGer.schluessel_N ;
|
|
cleft_N = DictGer.spalte_N ;
|
|
clement_A = DictGer.mild_A ;
|
|
clerestory_N = DictGer.obergaden_N ;
|
|
clergyman_N = DictGer.kleriker_N ;
|
|
clerical_A = DictGer.geistlich_A ;
|
|
clever_A = LexiconGer.clever_A ;
|
|
cliche_N = DictGer.klischee_N ;
|
|
click_N = DictGer.mausklick_N ;
|
|
client_N = DictGer.kunde_N ;
|
|
clientele_N = DictGer.klientel_N ;
|
|
cliff_N = DictGer.felsen_N ;
|
|
climb_V = DictGer.klettern_V ;
|
|
climb_V2 = P.dirV2 (DictGer.klettern_V) ;
|
|
climber_N = DictGer.bergsteiger_N ;
|
|
clinic_N = DictGer.klinik_N ;
|
|
clinical_A = DictGer.klinisch_A ;
|
|
clitoris_N = DictGer.kitzler_N ;
|
|
cloakroom_N = DictGer.garderobe_N ;
|
|
clock_N = DictGer.uhr_N ;
|
|
clod_N = DictGer.trottel_N ;
|
|
cloister_N = DictGer.kloster_N ;
|
|
clone_N = DictGer.klon_N ;
|
|
close_V = DictGer.beenden_V ;
|
|
close_V2 = LexiconGer.close_V2 ;
|
|
closet_N = DictGer.schrank_N ;
|
|
clot_N = DictGer.blutgerinnsel_N ;
|
|
cloth_N = DictGer.kleidungsstueck_N ;
|
|
clothesline_N = DictGer.waescheleine_N ;
|
|
cloud_N = LexiconGer.cloud_N ;
|
|
cloudy_A = DictGer.bewoelkt_A ;
|
|
clout_N = DictGer.einfluss_N ;
|
|
clove_N = DictGer.zehe_N ;
|
|
clown_N = DictGer.clown_N ;
|
|
club_N = DictGer.bengel_N ;
|
|
clubhouse_N = DictGer.klubhaus_N ;
|
|
clue_N = DictGer.anhaltspunkt_N ;
|
|
clump_N = DictGer.bueschel_N ;
|
|
clumsy_A = DictGer.klobig_A ;
|
|
cluster_N = DictGer.anhaeufung_N ;
|
|
clutch_N = DictGer.kupplung_N ;
|
|
clutter_N = DictGer.durcheinander_N ;
|
|
coach_N = DictGer.kutsche_N ;
|
|
coachman_N = DictGer.kutscher_N ;
|
|
coagulate_V = DictGer.gerinnen_V ;
|
|
coagulate_V2 = P.dirV2 (DictGer.gerinnen_V) ;
|
|
coal_N = DictGer.kohle_N ;
|
|
coalesce_V = DictGer.vereinigen_V ;
|
|
coalition_N = DictGer.koalition_N ;
|
|
coarse_A = DictGer.derb_A ;
|
|
coat_N = LexiconGer.coat_N ;
|
|
coax_V = DictGer.schmeicheln_V ;
|
|
coax_V2 = P.dirV2 (DictGer.schmeicheln_V) ;
|
|
cobbler_N = DictGer.schuster_N ;
|
|
cobra_N = DictGer.kobra_N ;
|
|
cobweb_N = DictGer.spinnennetz_N ;
|
|
cocaine_N = DictGer.cocaine_N ;
|
|
cock_N = DictGer.hahn_N ;
|
|
cockatoo_N = DictGer.kakadu_N ;
|
|
cockchafer_N = DictGer.maikaefer_N ;
|
|
cockerel_N = DictGer.hahn_N ;
|
|
cockroach_N = DictGer.kakerlake_N ;
|
|
cockscomb_N = DictGer.hahnenkamm_N ;
|
|
cocktail_N = DictGer.cocktail_N ;
|
|
cocoa_N = DictGer.kakaobohne_N ;
|
|
coconut_N = DictGer.kokosnuss_N ;
|
|
cod_N = DictGer.dorsch_N ;
|
|
code_N = DictGer.gesetzbuch_N ;
|
|
coerce_V2 = P.dirV2 (DictGer.zwingen_V) ;
|
|
coercion_N = DictGer.zwang_N ;
|
|
coffee_N = DictGer.kaffee_N ;
|
|
coffin_N = DictGer.sarg_N ;
|
|
cog_N = DictGer.kogge_N ;
|
|
cognac_N = DictGer.cognac_N ;
|
|
cognate_A = DictGer.verwandt_A ;
|
|
cognition_N = DictGer.kognition_N ;
|
|
cohere_V = DictGer.binden_8_V ;
|
|
coherence_N = DictGer.zusammenhang_N ;
|
|
coherent_A = DictGer.kohaerent_A ;
|
|
cohesive_A = DictGer.zusammenhaengend_A ;
|
|
cohort_N = DictGer.kohorte_N ;
|
|
coil_N = DictGer.spule_N ;
|
|
coin_N = DictGer.chip_N ;
|
|
coincidence_N = DictGer.koinzidenz_N ;
|
|
coke_N = DictGer.koks_N ;
|
|
colander_N = DictGer.durchschlag_N ;
|
|
cold_A = LexiconGer.cold_A ;
|
|
coleslaw_N = DictGer.krautsalat_N ;
|
|
colic_N = DictGer.kolik_N ;
|
|
collage_N = DictGer.collage_N ;
|
|
collapse_V = DictGer.kollabieren_V ;
|
|
collapse_V2 = P.dirV2 (DictGer.kollabieren_V) ;
|
|
collar_N = DictGer.halskette_N ;
|
|
collarbone_N = DictGer.schluesselbein_N ;
|
|
collate_V2 = P.dirV2 (DictGer.mischen_5_V) ;
|
|
colleague_N = DictGer.kollege_N ;
|
|
collect_V = DictGer.sammeln_V ;
|
|
collect_V2 = P.dirV2 (DictGer.sammeln_V) ;
|
|
collection_N = DictGer.menge_N ;
|
|
collector_N = DictGer.kassierer_N ;
|
|
college_N = DictGer.fachhochschule_N ;
|
|
collide_V = DictGer.kollidieren_V ;
|
|
collision_N = DictGer.kollision_N ;
|
|
collocation_N = DictGer.kollokation_N ;
|
|
colloquial_A = DictGer.umgangssprachlich_A ;
|
|
colloquialism_N = DictGer.gemeinsprache_N ;
|
|
colon_N = DictGer.doppelpunkt_N ;
|
|
colonnade_N = DictGer.kolonnade_N ;
|
|
colony_N = DictGer.kolonie_N ;
|
|
colossal_A = DictGer.kolossal_A ;
|
|
colossus_N = DictGer.gigant_N ;
|
|
coloured_A = DictGer.bunt_A ;
|
|
colourless_A = DictGer.farblos_A ;
|
|
columbine_N = DictGer.akelei_N ;
|
|
column_N = DictGer.kolonne_N ;
|
|
comb_N = DictGer.kamm_N ;
|
|
combat_N = DictGer.kampf_N ;
|
|
combination_N = DictGer.kombination_N ;
|
|
combine_V = DictGer.kombinieren_V ;
|
|
combine_V2 = P.dirV2 (DictGer.kombinieren_V) ;
|
|
combustible_A = DictGer.brennbar_A ;
|
|
combustion_N = DictGer.verbrennung_N ;
|
|
come_V = LexiconGer.come_V ;
|
|
come_V2 = P.dirV2 (DictGer.kommen_7_V) ;
|
|
comeback_N = DictGer.comeback_N ;
|
|
comedian_N = DictGer.komiker_N ;
|
|
comedy_N = DictGer.komoedie_N ;
|
|
comet_N = DictGer.komet_N ;
|
|
comfort_N = DictGer.bequemlichkeit_N ;
|
|
comfortable_A = DictGer.behaglich_A ;
|
|
comfy_A = DictGer.bequem_A ;
|
|
comma_N = DictGer.beistrich_N ;
|
|
command_N = DictGer.befehl_N ;
|
|
commander_N = DictGer.befehlshaber_N ;
|
|
commandment_N = DictGer.gebot_N ;
|
|
commemorate_V2 = P.dirV2 (DictGer.gedenken_V) ;
|
|
commence_V = DictGer.beginnen_V ;
|
|
commence_V2 = P.dirV2 (DictGer.beginnen_V) ;
|
|
comment_N = DictGer.kommentar_N ;
|
|
commentary_N = DictGer.kommentar_N ;
|
|
commercial_N = DictGer.werbung_N ;
|
|
commission_N = DictGer.kommission_N ;
|
|
commissioner_N = DictGer.kommissar_N ;
|
|
commit_V2 = P.dirV2 (DictGer.begehen_V) ;
|
|
commitment_N = DictGer.bindung_N ;
|
|
committee_N = DictGer.komitee_N ;
|
|
commodity_N = DictGer.ware_N ;
|
|
common_A = DictGer.gemein_A ;
|
|
communicate_V = DictGer.kommunizieren_V ;
|
|
communicate_V2 = P.dirV2 (DictGer.kommunizieren_V) ;
|
|
communication_N = DictGer.kommunikation_N ;
|
|
communicative_A = DictGer.kommunikativ_A ;
|
|
communist_A = DictGer.kommunistisch_A ;
|
|
community_N = DictGer.gemeinde_N ;
|
|
commute_V = DictGer.pendeln_V ;
|
|
commute_V2 = P.dirV2 (DictGer.pendeln_V) ;
|
|
commuter_N = DictGer.pendler_N ;
|
|
companion_N = DictGer.gefaehrte_N ;
|
|
company_N = DictGer.firma_N ;
|
|
comparable_A = DictGer.vergleichbar_A ;
|
|
compare_V = DictGer.steigern_V ;
|
|
compare_V2 = P.dirV2 (DictGer.steigern_V) ;
|
|
comparison_N = DictGer.gegenueberstellung_N ;
|
|
compartment_N = DictGer.abteil_N ;
|
|
compass_N = DictGer.kompass_N ;
|
|
compatibility_N = DictGer.kompatibilitaet_N ;
|
|
compatible_A = DictGer.austauschbar_A ;
|
|
compel_V2 = P.dirV2 (DictGer.zwingen_V) ;
|
|
compensate_V = DictGer.kompensieren_V ;
|
|
compensate_V2 = P.dirV2 (DictGer.kompensieren_V) ;
|
|
compensation_N = DictGer.abfindung_N ;
|
|
compete_V = DictGer.streiten_V ;
|
|
competence_N = DictGer.befugnis_N ;
|
|
competent_A = DictGer.kompetent_A ;
|
|
competition_N = DictGer.konkurrenz_N ;
|
|
competitor_N = DictGer.konkurrent_N ;
|
|
compile_V2 = P.dirV2 (DictGer.kompilieren_V) ;
|
|
compiler_N = DictGer.compiler_N ;
|
|
complain_V = DictGer.klagen_1_V ;
|
|
complaint_N = DictGer.anzeige_N ;
|
|
complex_A = DictGer.kompliziert_A ;
|
|
complexion_N = DictGer.teint_N ;
|
|
complexity_N = DictGer.schwierigkeit_N ;
|
|
complicate_V2 = P.dirV2 (DictGer.komplizieren_V) ;
|
|
complicated_A = DictGer.kompliziert_A ;
|
|
complication_N = DictGer.komplikation_N ;
|
|
compliment_N = DictGer.kompliment_N ;
|
|
complimentary_A = DictGer.gratis_A ;
|
|
component_N = DictGer.komponente_N ;
|
|
compose_V = DictGer.bilden_6_V ;
|
|
compose_V2 = P.dirV2 (DictGer.bilden_6_V) ;
|
|
composer_N = DictGer.komponist_N ;
|
|
composite_A = DictGer.zusammengesetzt_A ;
|
|
composition_N = DictGer.komposition_N ;
|
|
compote_N = DictGer.kompott_N ;
|
|
compound_N = DictGer.mischung_N ;
|
|
comprehend_V2 = P.dirV2 (DictGer.begreifen_V) ;
|
|
comprehension_N = DictGer.verstaendnis_N ;
|
|
comprehensive_A = DictGer.umfassend_A ;
|
|
compress_V2 = P.dirV2 (DictGer.komprimieren_V) ;
|
|
compression_N = DictGer.kompression_N ;
|
|
comprise_V2 = P.dirV2 (DictGer.beinhalten_V) ;
|
|
compromise_N = DictGer.ausgleich_N ;
|
|
compulsory_A = DictGer.gesetzlich_A ;
|
|
computation_N = DictGer.berechnung_N ;
|
|
computer_N = LexiconGer.computer_N ;
|
|
comrade_N = DictGer.genosse_N ;
|
|
con_V2 = P.dirV2 (DictGer.betruegen_V) ;
|
|
concatenation_N = DictGer.verkettung_N ;
|
|
concave_A = DictGer.konkav_A ;
|
|
conceit_N = DictGer.einbildung_N ;
|
|
conceivable_A = DictGer.denkbar_A ;
|
|
conceive_V = DictGer.empfangen_V ;
|
|
conceive_V2 = P.dirV2 (DictGer.empfangen_V) ;
|
|
concentrate_V = DictGer.konzentrieren_V ;
|
|
concentrate_V2 = P.dirV2 (DictGer.konzentrieren_V) ;
|
|
concentration_N = DictGer.konzentration_N ;
|
|
concept_N = DictGer.begriff_N ;
|
|
concern_N = DictGer.betroffenheit_N ;
|
|
concierge_N = DictGer.hausmeister_N ;
|
|
concise_A = DictGer.buendig_A ;
|
|
conclude_V = DictGer.beenden_V ;
|
|
conclude_V2 = P.dirV2 (DictGer.beenden_V) ;
|
|
conclusion_N = DictGer.abschluss_N ;
|
|
conclusive_A = DictGer.endgueltig_A ;
|
|
concordat_N = DictGer.konkordat_N ;
|
|
concrete_A = DictGer.bestimmt_A ;
|
|
concur_V = DictGer.uebereinstimmen_V ;
|
|
condense_V = DictGer.kondensieren_V ;
|
|
condense_V2 = P.dirV2 (DictGer.kondensieren_V) ;
|
|
condescending_A = DictGer.herablassend_A ;
|
|
condition_N = DictGer.bedingung_N ;
|
|
condolence_N = DictGer.kondolenz_N ;
|
|
condominium_N = DictGer.eigentumswohnung_N ;
|
|
condor_N = DictGer.kondor_N ;
|
|
conduction_N = DictGer.leitung_N ;
|
|
conductor_N = DictGer.dirigent_N ;
|
|
conduit_N = DictGer.kabelkanal_N ;
|
|
cone_N = DictGer.kegel_N ;
|
|
confectionery_N = DictGer.konditorei_N ;
|
|
confederation_N = DictGer.bund_N ;
|
|
conference_N = DictGer.konferenz_N ;
|
|
confess_V = DictGer.beichten_V ;
|
|
confess_V2 = P.dirV2 (DictGer.beichten_V) ;
|
|
confession_N = DictGer.beichte_N ;
|
|
confessor_N = DictGer.beichtvater_N ;
|
|
confidence_N = DictGer.zuversicht_N ;
|
|
confidential_A = DictGer.vertraulich_A ;
|
|
configuration_N = DictGer.konfiguration_N ;
|
|
configure_V2 = P.dirV2 (DictGer.konfigurieren_V) ;
|
|
confine_V2 = P.dirV2 (DictGer.beschraenken_V) ;
|
|
confirm_V2 = P.dirV2 (DictGer.bekraeftigen_V) ;
|
|
confirmation_N = DictGer.bestaetigung_N ;
|
|
confiscate_V2 = P.dirV2 (DictGer.konfiszieren_V) ;
|
|
conflict_N = DictGer.inkompatibilitaet_N ;
|
|
confront_V2 = P.dirV2 (DictGer.begegnen_V) ;
|
|
confrontation_N = DictGer.gegenueberstellung_N ;
|
|
confuse_V2 = P.dirV2 (DictGer.vermischen_V) ;
|
|
congenial_A = DictGer.freundlich_A ;
|
|
congenital_A = DictGer.angeboren_A ;
|
|
conglomerate_N = DictGer.konglomerat_N ;
|
|
congratulate_V2 = P.dirV2 (DictGer.gratulieren_V) ;
|
|
congregation_N = DictGer.versammlung_N ;
|
|
congress_N = DictGer.kongress_N ;
|
|
congruent_A = DictGer.kongruent_A ;
|
|
conifer_N = DictGer.konifere_N ;
|
|
conjecture_N = DictGer.hypothese_N ;
|
|
conjugate_V = DictGer.konjugieren_V ;
|
|
conjugate_V2 = P.dirV2 (DictGer.konjugieren_V) ;
|
|
conjugation_N = DictGer.konjugation_N ;
|
|
conjunction_N = DictGer.bindewort_N ;
|
|
connect_V = DictGer.anschliessen_V ;
|
|
connect_V2 = P.dirV2 (DictGer.anschliessen_V) ;
|
|
connection_N = DictGer.verbindung_N ;
|
|
connoisseur_N = DictGer.kenner_N ;
|
|
connote_V2 = P.dirV2 (DictGer.bedeuten_V) ;
|
|
conquer_V2 = P.dirV2 (DictGer.erobern_V) ;
|
|
conscience_N = DictGer.gewissen_N ;
|
|
consecrate_V2 = P.dirV2 (DictGer.weihen_6_V) ;
|
|
consecration_N = DictGer.weihe_N ;
|
|
consecutive_A = DictGer.fortlaufend_A ;
|
|
consensus_N = DictGer.konsens_N ;
|
|
consequence_N = DictGer.folge_N ;
|
|
consider_V = DictGer.ueberlegen_V ;
|
|
consider_V2 = P.dirV2 (DictGer.ueberlegen_V) ;
|
|
considerable_A = DictGer.betraechtlich_A ;
|
|
consideration_N = DictGer.ruecksicht_N ;
|
|
consistency_N = DictGer.konsistenz_N ;
|
|
consistent_A = DictGer.konsistent_A ;
|
|
console_N = DictGer.konsole_N ;
|
|
consolidate_V = DictGer.konsolidieren_V ;
|
|
consolidate_V2 = P.dirV2 (DictGer.konsolidieren_V) ;
|
|
consonant_N = DictGer.konsonant_N ;
|
|
conspicuous_A = DictGer.auffaellig_A ;
|
|
conspiracy_N = DictGer.verschwoerung_N ;
|
|
conspiratorial_A = DictGer.konspirativ_A ;
|
|
constant_A = DictGer.bestaendig_A ;
|
|
constellation_N = DictGer.konstellation_N ;
|
|
constipation_N = DictGer.verstopfung_N ;
|
|
constitute_V2 = P.dirV2 (DictGer.begruenden_V) ;
|
|
constitution_N = DictGer.grundgesetz_N ;
|
|
constrain_V2 = P.dirV2 (DictGer.behindern_V) ;
|
|
constrict_V2 = P.dirV2 (DictGer.verengen_V) ;
|
|
construction_N = DictGer.aufbau_N ;
|
|
constructive_A = DictGer.konstruktiv_A ;
|
|
constructor_N = DictGer.konstruktor_N ;
|
|
consul_N = DictGer.konsul_N ;
|
|
consulate_N = DictGer.konsulat_N ;
|
|
consultant_N = DictGer.berater_N ;
|
|
consume_V = DictGer.verbrauchen_V ;
|
|
consume_V2 = P.dirV2 (DictGer.verbrauchen_V) ;
|
|
consumer_N = DictGer.konsument_N ;
|
|
consummate_A = DictGer.perfekt_A ;
|
|
consumption_N = DictGer.verbrauch_N ;
|
|
contact_N = DictGer.beruehrung_N ;
|
|
contagion_N = DictGer.ansteckung_N ;
|
|
contagious_A = DictGer.ansteckend_A ;
|
|
container_N = DictGer.behaelter_N ;
|
|
contamination_N = DictGer.kontamination_N ;
|
|
contemporary_A = DictGer.zeitgenoessisch_A ;
|
|
contempt_N = DictGer.blamage_N ;
|
|
content_N = DictGer.inhalt_N ;
|
|
contentious_A = DictGer.streitsuechtig_A ;
|
|
contest_N = DictGer.wettbewerb_N ;
|
|
context_N = DictGer.kontext_N ;
|
|
contiguous_A = DictGer.angrenzend_A ;
|
|
continent_N = DictGer.erdteil_N ;
|
|
continuous_A = DictGer.kontinuierlich_A ;
|
|
contraception_N = DictGer.verhuetung_N ;
|
|
contraceptive_A = DictGer.empfaengnisverhuetend_A ;
|
|
contract_N = DictGer.vertrag_N ;
|
|
contraction_N = DictGer.kontraktion_N ;
|
|
contradict_V2 = P.dirV2 (DictGer.widersprechen_V) ;
|
|
contradiction_N = DictGer.gegensatz_N ;
|
|
contrast_N = DictGer.kontrast_N ;
|
|
contribution_N = DictGer.beitrag_N ;
|
|
contrivance_N = DictGer.erfindung_N ;
|
|
control_V = DictGer.kontrollieren_V ;
|
|
control_V2 = P.dirV2 (DictGer.kontrollieren_V) ;
|
|
controller_N = DictGer.aufseher_N ;
|
|
controversial_A = DictGer.kontrovers_A ;
|
|
controversy_N = DictGer.kontroverse_N ;
|
|
contusion_N = DictGer.prellung_N ;
|
|
conundrum_N = DictGer.raetsel_N ;
|
|
convenience_N = DictGer.annehmlichkeit_N ;
|
|
convenient_A = DictGer.bequem_A ;
|
|
convention_N = DictGer.konvention_N ;
|
|
conventional_A = DictGer.herkoemmlich_A ;
|
|
converge_V = DictGer.konvergieren_V ;
|
|
conversation_N = DictGer.gespraech_N ;
|
|
conversion_N = DictGer.umwandlung_N ;
|
|
convex_A = DictGer.konvex_A ;
|
|
convey_V2 = P.dirV2 (DictGer.befoerdern_V) ;
|
|
conviction_N = DictGer.ueberzeugung_N ;
|
|
convince_V2 = P.dirV2 (DictGer.ueberzeugen_V) ;
|
|
convoy_N = DictGer.geleitzug_N ;
|
|
cook_N = DictGer.koch_N ;
|
|
cookbook_N = DictGer.kochbuch_N ;
|
|
cooker_N = DictGer.herd_N ;
|
|
cool_A = DictGer.cool_A ;
|
|
cooler_N = DictGer.kuehler_N ;
|
|
coolie_N = DictGer.kuli_N ;
|
|
cooper_N = DictGer.kuefer_N ;
|
|
cooperate_V = DictGer.kooperieren_V ;
|
|
cooperative_A = DictGer.kooperativ_A ;
|
|
coordination_N = DictGer.koordination_N ;
|
|
cop_N = DictGer.gendarm_N ;
|
|
cope_V = DictGer.schaffen_5_V ;
|
|
copper_N = DictGer.bulle_N ;
|
|
copulate_V = DictGer.kopulieren_V ;
|
|
copy_N = DictGer.kopie_N ;
|
|
copyright_N = DictGer.urheberrecht_N ;
|
|
coquetry_N = DictGer.koketterie_N ;
|
|
coquettish_A = DictGer.kokett_A ;
|
|
coral_N = DictGer.koralle_N ;
|
|
cord_N = DictGer.kabel_N ;
|
|
cordial_A = DictGer.herzlich_A ;
|
|
core_N = DictGer.kern_N ;
|
|
cork_N = DictGer.kork_N ;
|
|
corkscrew_N = DictGer.korkenzieher_N ;
|
|
cormorant_N = DictGer.kormoran_N ;
|
|
corn_N = DictGer.huehnerauge_N ;
|
|
corncrake_N = DictGer.wachtelkoenig_N ;
|
|
cornea_N = DictGer.hornhaut_N ;
|
|
corner_N = DictGer.ecke_N ;
|
|
cornerstone_N = DictGer.grundstein_N ;
|
|
cornet_N = DictGer.kornett_N ;
|
|
cornflower_N = DictGer.kornblume_N ;
|
|
cornucopia_N = DictGer.fuelle_N ;
|
|
corollary_N = DictGer.korollar_N ;
|
|
corona_N = DictGer.korona_N ;
|
|
corporal_A = DictGer.koerperlich_A ;
|
|
corporeal_A = DictGer.koerperlich_A ;
|
|
corps_N = DictGer.korps_N ;
|
|
corpse_N = DictGer.leiche_N ;
|
|
corpulent_A = DictGer.korpulent_A ;
|
|
correct_A = LexiconGer.correct_A ;
|
|
correction_N = DictGer.berichtigung_N ;
|
|
correctness_N = DictGer.richtigkeit_N ;
|
|
correlation_N = DictGer.korrelation_N ;
|
|
correspond_V = DictGer.entsprechen_V ;
|
|
corridor_N = DictGer.gang_N ;
|
|
corrode_V = DictGer.rosten_V ;
|
|
corrode_V2 = P.dirV2 (DictGer.rosten_V) ;
|
|
corrupt_A = DictGer.korrupt_A ;
|
|
corruptible_A = DictGer.bestechlich_A ;
|
|
corsair_N = DictGer.korsar_N ;
|
|
cosine_N = DictGer.kosinus_N ;
|
|
cosmetic_A = DictGer.kosmetisch_A ;
|
|
cosmic_A = DictGer.kosmisch_A ;
|
|
cosmonaut_N = DictGer.kosmonaut_N ;
|
|
cost_N = DictGer.verlust_N ;
|
|
costume_N = DictGer.kostuem_N ;
|
|
cosy_A = DictGer.gemuetlich_A ;
|
|
cot_N = DictGer.feldbett_N ;
|
|
cotton_N = DictGer.baumwolle_N ;
|
|
couch_N = DictGer.sofa_N ;
|
|
cougar_N = DictGer.puma_N ;
|
|
cough_V = DictGer.husten_V ;
|
|
cough_V2 = P.dirV2 (DictGer.husten_V) ;
|
|
council_N = DictGer.rat_N ;
|
|
counsel_N = DictGer.anwalt_N ;
|
|
count_N = DictGer.number_N ;
|
|
count_V2 = LexiconGer.count_V2 ;
|
|
counter_N = DictGer.schalter_N ;
|
|
counteract_V2 = P.dirV2 (DictGer.bekaempfen_V) ;
|
|
counterfeit_A = DictGer.falsch_A ;
|
|
counterpart_N = DictGer.duplikat_N ;
|
|
counterpoint_N = DictGer.kontrapunkt_N ;
|
|
countertenor_N = DictGer.countertenor_N ;
|
|
countess_N = DictGer.graefin_N ;
|
|
country_N = LexiconGer.country_N ;
|
|
countryman_N = DictGer.landsmaennin_N ;
|
|
county_N = DictGer.bezirk_N ;
|
|
coup_N = DictGer.putsch_N ;
|
|
coupe_N = DictGer.coupe_N ;
|
|
couple_N = DictGer.paar_N ;
|
|
coupling_N = DictGer.coupling_N ;
|
|
coupon_N = DictGer.gutschein_N ;
|
|
courageous_A = DictGer.mutig_A ;
|
|
courier_N = DictGer.reisefuehrer_N ;
|
|
course_N = DictGer.bahn_N ;
|
|
court_N = DictGer.gericht_N ;
|
|
courteous_A = DictGer.hoeflich_A ;
|
|
courtesan_N = DictGer.kurtisane_N ;
|
|
courtesy_N = DictGer.hoeflichkeit_N ;
|
|
courtyard_N = DictGer.hof_N ;
|
|
cousin_N = LexiconGer.cousin_N ;
|
|
covenant_N = DictGer.zusage_N ;
|
|
cover_N = DictGer.abdeckung_N ;
|
|
covet_V2 = P.dirV2 (DictGer.begehren_0_V) ;
|
|
covetous_A = DictGer.begierig_A ;
|
|
cow_N = LexiconGer.cow_N ;
|
|
coward_N = DictGer.angsthase_N ;
|
|
cowboy_N = DictGer.cowboy_N ;
|
|
cower_V = DictGer.kauern_V ;
|
|
cowshed_N = DictGer.kuhstall_N ;
|
|
coy_A = DictGer.keusch_A ;
|
|
coyote_N = DictGer.kojote_N ;
|
|
coypu_N = DictGer.nutria_N ;
|
|
cozy_A = DictGer.gemuetlich_A ;
|
|
crab_N = DictGer.krabbe_N ;
|
|
crack_N = DictGer.knall_N ;
|
|
cradle_N = DictGer.wiege_N ;
|
|
craft_N = DictGer.handwerk_N ;
|
|
craftsman_N = DictGer.handwerker_N ;
|
|
cramp_N = DictGer.klammer_N ;
|
|
cranberry_N = DictGer.preiselbeere_N ;
|
|
crane_N = DictGer.kranich_N ;
|
|
cranial_A = DictGer.kranial_A ;
|
|
cranium_N = DictGer.hirnschale_N ;
|
|
cranky_A = DictGer.launisch_A ;
|
|
cranny_N = DictGer.spalt_N ;
|
|
crash_N = DictGer.absturz_N ;
|
|
crater_N = DictGer.krater_N ;
|
|
craving_N = DictGer.begierde_N ;
|
|
crawl_V = DictGer.krabbeln_V ;
|
|
crazy_A = DictGer.verrueckt_A ;
|
|
cream_N = DictGer.cream_N ;
|
|
crease_N = DictGer.falte_N ;
|
|
create_V = DictGer.entwerfen_V ;
|
|
create_V2 = P.dirV2 (DictGer.entwerfen_V) ;
|
|
creation_N = DictGer.schoepfung_N ;
|
|
creative_A = DictGer.kreativ_A ;
|
|
creator_N = DictGer.schoepfer_N ;
|
|
creature_N = DictGer.geschoepf_N ;
|
|
credence_N = DictGer.beglaubigung_N ;
|
|
credible_A = DictGer.glaubwuerdig_A ;
|
|
creditor_N = DictGer.glaeubiger_N ;
|
|
creed_N = DictGer.glaubensbekenntnis_N ;
|
|
creek_N = DictGer.bach_N ;
|
|
creep_N = DictGer.knilch_N ;
|
|
creepy_A = DictGer.gruselig_A ;
|
|
cremate_V2 = P.dirV2 (DictGer.kremieren_V) ;
|
|
cremation_N = DictGer.einaescherung_N ;
|
|
crematorium_N = DictGer.krematorium_N ;
|
|
crescent_N = DictGer.croissant_N ;
|
|
cress_N = DictGer.kresse_N ;
|
|
cretin_N = DictGer.kretin_N ;
|
|
crevice_N = DictGer.spalt_N ;
|
|
crew_N = DictGer.besatzung_N ;
|
|
crib_N = DictGer.krippe_N ;
|
|
cricket_N = DictGer.grille_N ;
|
|
crime_N = DictGer.verbrechen_N ;
|
|
criminal_A = DictGer.kriminell_A ;
|
|
criminalize_V2 = P.dirV2 (DictGer.kriminalisieren_V) ;
|
|
crisis_N = DictGer.krise_N ;
|
|
criterion_N = DictGer.kriterium_N ;
|
|
critic_N = DictGer.kritiker_N ;
|
|
critical_A = DictGer.kritisch_A ;
|
|
criticism_N = DictGer.kritik_N ;
|
|
critique_N = DictGer.kritik_N ;
|
|
crockery_N = DictGer.geschirr_N ;
|
|
crocodile_N = DictGer.krokodil_N ;
|
|
crocus_N = DictGer.krokus_N ;
|
|
crony_N = DictGer.freund_N ;
|
|
crook_N = DictGer.ganove_N ;
|
|
crop_N = DictGer.getreide_N ;
|
|
croquette_N = DictGer.krokette_N ;
|
|
cross_N = DictGer.flanke_N ;
|
|
crossbow_N = DictGer.armbrust_N ;
|
|
crossing_N = DictGer.kreuzung_N ;
|
|
crosswalk_N = DictGer.zebrastreifen_N ;
|
|
crotch_N = DictGer.schritt_N ;
|
|
crow_N = DictGer.brecheisen_N ;
|
|
crown_N = DictGer.krone_N ;
|
|
crucial_A = DictGer.ausschlaggebend_A ;
|
|
crucible_N = DictGer.tiegel_N ;
|
|
crucifix_N = DictGer.kruzifix_N ;
|
|
crucifixion_N = DictGer.kreuzigung_N ;
|
|
crucify_V2 = P.dirV2 (DictGer.kreuzigen_V) ;
|
|
crude_A = DictGer.grob_A ;
|
|
cruel_A = DictGer.grausam_A ;
|
|
cruelty_N = DictGer.grausamkeit_N ;
|
|
cruise_N = DictGer.kreuzfahrt_N ;
|
|
cruiser_N = DictGer.kreuzer_N ;
|
|
crumb_N = DictGer.brosame_N ;
|
|
crusade_N = DictGer.feldzug_N ;
|
|
crush_N = DictGer.schwarm_N ;
|
|
crusty_A = DictGer.muerrisch_A ;
|
|
crutch_N = DictGer.kruecke_N ;
|
|
cry_V = DictGer.schreien_V ;
|
|
cry_V2 = P.dirV2 (DictGer.schreien_V) ;
|
|
crybaby_N = DictGer.heulsuse_N ;
|
|
cryptic_A = DictGer.kryptisch_A ;
|
|
crystal_N = DictGer.kristall_N ;
|
|
crystallization_N = DictGer.kristallisation_N ;
|
|
cub_N = DictGer.welpe_N ;
|
|
cube_N = DictGer.kubus_N ;
|
|
cuckold_N = DictGer.hahnrei_N ;
|
|
cucumber_N = DictGer.gurke_N ;
|
|
cue_N = DictGer.queue_N ;
|
|
cuff_N = DictGer.manschette_N ;
|
|
cuisine_N = DictGer.kueche_N ;
|
|
culinary_A = DictGer.kulinarisch_A ;
|
|
culminate_V = DictGer.gipfeln_V ;
|
|
culminate_V2 = P.dirV2 (DictGer.gipfeln_V) ;
|
|
cult_N = DictGer.kultus_N ;
|
|
cultivate_V2 = P.dirV2 (DictGer.bestellen_5_V) ;
|
|
cultivation_N = DictGer.bildung_N ;
|
|
cultural_A = DictGer.kulturell_A ;
|
|
culture_N = DictGer.kultur_N ;
|
|
culvert_N = DictGer.dueker_N ;
|
|
cumbersome_A = DictGer.beschwerlich_A ;
|
|
cummerbund_N = DictGer.kummerbund_N ;
|
|
cumulus_N = DictGer.haufenwolke_N ;
|
|
cunning_A = DictGer.gerissen_A ;
|
|
cunt_N = DictGer.fotze_N ;
|
|
cup_N = DictGer.becher_N ;
|
|
cupboard_N = DictGer.schrank_N ;
|
|
cupola_N = DictGer.kuppel_N ;
|
|
cur_N = DictGer.koeter_N ;
|
|
curacao_N = DictGer.curacao_N ;
|
|
curator_N = DictGer.kurator_N ;
|
|
curb_N = DictGer.kandare_N ;
|
|
curfew_N = DictGer.ausgangssperre_N ;
|
|
curious_A = DictGer.kurios_A ;
|
|
curmudgeon_N = DictGer.miesepeter_N ;
|
|
currant_N = DictGer.johannisbeere_N ;
|
|
currency_N = DictGer.waehrung_N ;
|
|
current_N = DictGer.strom_N ;
|
|
curry_N = DictGer.curry_N ;
|
|
curse_N = DictGer.fluch_N ;
|
|
cursive_A = DictGer.kursiv_A ;
|
|
curtail_V2 = P.dirV2 (DictGer.beschneiden_V) ;
|
|
curtain_N = DictGer.gardine_N ;
|
|
cushion_N = DictGer.bande_N ;
|
|
custody_N = DictGer.sorgerecht_N ;
|
|
custom_N = DictGer.brauch_N ;
|
|
cut_V2 = LexiconGer.cut_V2 ;
|
|
cute_A = DictGer.goldig_A ;
|
|
cutlass_N = DictGer.machete_N ;
|
|
cutlery_N = DictGer.essbesteck_N ;
|
|
cutlet_N = DictGer.schnitzel_N ;
|
|
cutter_N = DictGer.kutter_N ;
|
|
cuttlefish_N = DictGer.kopffuesser_N ;
|
|
cyanide_N = DictGer.zyanid_N ;
|
|
cyclamen_N = DictGer.alpenveilchen_N ;
|
|
cycle_N = DictGer.programm_N ;
|
|
cyclic_A = DictGer.periodisch_A ;
|
|
cyclical_A = DictGer.zyklisch_A ;
|
|
cyclist_N = DictGer.radfahrer_N ;
|
|
cyclone_N = DictGer.zyklon_N ;
|
|
cylinder_N = DictGer.rolle_N ;
|
|
cylindrical_A = DictGer.zylindrisch_A ;
|
|
cymbal_N = DictGer.becken_N ;
|
|
cynical_A = DictGer.zynisch_A ;
|
|
cynicism_N = DictGer.zynismus_N ;
|
|
cynosure_N = DictGer.anziehungspunkt_N ;
|
|
cypress_N = DictGer.zypresse_N ;
|
|
cyst_N = DictGer.zyste_N ;
|
|
dace_N = DictGer.weissfisch_N ;
|
|
dacha_N = DictGer.datsche_N ;
|
|
dachshund_N = DictGer.dachshund_N ;
|
|
dad_N = DictGer.papa_N ;
|
|
daddy_N = DictGer.papa_N ;
|
|
daft_A = DictGer.bescheuert_A ;
|
|
dagger_N = DictGer.dolch_N ;
|
|
dahlia_N = DictGer.dahlie_N ;
|
|
daily_A = DictGer.taeglich_A ;
|
|
dairy_N = DictGer.molkerei_N ;
|
|
daisy_N = DictGer.gaensebluemchen_N ;
|
|
dam_N = DictGer.damm_N ;
|
|
damage_N = DictGer.schaden_N ;
|
|
damned_A = DictGer.verdammt_A ;
|
|
damp_A = DictGer.feucht_A ;
|
|
damson_N = DictGer.zwetschge_N ;
|
|
dance_N = DictGer.tanz_N ;
|
|
dancer_N = DictGer.taenzer_N ;
|
|
dandelion_N = DictGer.loewenzahn_N ;
|
|
danger_N = DictGer.gefahr_N ;
|
|
dangerous_A = DictGer.gefaehrlich_A ;
|
|
dare_V = DictGer.riskieren_V ;
|
|
dare_V2 = P.dirV2 (DictGer.riskieren_V) ;
|
|
dark_A = DictGer.dunkel_A ;
|
|
darkness_N = DictGer.dunkelheit_N ;
|
|
darkroom_N = DictGer.darkroom_N ;
|
|
darling_N = DictGer.liebling_N ;
|
|
dash_N = DictGer.gedankenstrich_N ;
|
|
dashboard_N = DictGer.armaturenbrett__N ;
|
|
dashing_A = DictGer.schneidig_A ;
|
|
date_N = DictGer.date_N ;
|
|
dated_A = DictGer.anachronistisch_A ;
|
|
daub_V = DictGer.schmieren_8_V ;
|
|
daub_V2 = P.dirV2 (DictGer.schmieren_8_V) ;
|
|
daughter_N = DictGer.tochter_N ;
|
|
dawdle_V = DictGer.troedeln_V ;
|
|
dawdle_V2 = P.dirV2 (DictGer.troedeln_V) ;
|
|
day_N = LexiconGer.day_N ;
|
|
daybreak_N = DictGer.tagesanbruch_N ;
|
|
daytime_N = DictGer.tageszeit_N ;
|
|
deactivate_V2 = P.dirV2 (DictGer.deaktivieren_V) ;
|
|
dead_A = DictGer.genau_A ;
|
|
deadline_N = DictGer.frist_N ;
|
|
deadlock_N = DictGer.stillstand_N ;
|
|
deadly_A = DictGer.toedlich_A ;
|
|
deadpan_A = DictGer.ausdruckslos_A ;
|
|
deaf_A = DictGer.gehoerlos_A ;
|
|
deafness_N = DictGer.schwerhoerigkeit_N ;
|
|
deal_N = DictGer.abkommen_N ;
|
|
dealer_N = DictGer.dealer_N ;
|
|
dear_A = DictGer.teuer_A ;
|
|
dearth_N = DictGer.hungersnot_N ;
|
|
death_N = DictGer.tod_N ;
|
|
deathbed_N = DictGer.sterbebett_N ;
|
|
deathly_A = DictGer.toedlich_A ;
|
|
debate_N = DictGer.debatte_N ;
|
|
debt_N = DictGer.schuld_N ;
|
|
debtor_N = DictGer.schuldner__N ;
|
|
decade_N = DictGer.dekade_N ;
|
|
decadent_A = DictGer.dekadent_A ;
|
|
decapitate_V2 = P.dirV2 (DictGer.enthaupten_V) ;
|
|
decapitation_N = DictGer.enthauptung_N ;
|
|
deceit_N = DictGer.falschheit_N ;
|
|
deceive_V2 = P.dirV2 (DictGer.betruegen_V) ;
|
|
decency_N = DictGer.anstand_N ;
|
|
decent_A = DictGer.anstaendig_A ;
|
|
deception_N = DictGer.taeuschung_N ;
|
|
decide_V = DictGer.beschliessen_V ;
|
|
decide_V2 = P.dirV2 (DictGer.beschliessen_V) ;
|
|
deciduous_A = DictGer.sommergruen_A ;
|
|
decimate_V2 = P.dirV2 (DictGer.dezimieren_V) ;
|
|
decipher_V2 = P.dirV2 (DictGer.dechiffrieren_V) ;
|
|
decision_N = DictGer.beschluss_N ;
|
|
decisive_A = DictGer.ausschlaggebend_A ;
|
|
deck_N = DictGer.deck_N ;
|
|
declaration_N = DictGer.deklaration_N ;
|
|
declare_V = DictGer.deklarieren_V ;
|
|
declare_V2 = P.dirV2 (DictGer.deklarieren_V) ;
|
|
declension_N = DictGer.beugung_N ;
|
|
declination_N = DictGer.deklination_N ;
|
|
decline_N = DictGer.abnahme_N ;
|
|
decomposition_N = DictGer.abbau_N ;
|
|
decoration_N = DictGer.auszeichnung_N ;
|
|
decoy_N = DictGer.lockvogel_N ;
|
|
decrease_V = DictGer.verringern_V ;
|
|
decrease_V2 = P.dirV2 (DictGer.verringern_V) ;
|
|
dedication_N = DictGer.widmung_N ;
|
|
deed_N = DictGer.akt_N ;
|
|
deem_V2 = P.dirV2 (DictGer.halten_5_V) ;
|
|
deep_A = DictGer.dunkel_A ;
|
|
deepen_V = DictGer.vergroessern_V ;
|
|
deepen_V2 = P.dirV2 (DictGer.vergroessern_V) ;
|
|
defamation_N = DictGer.verleumdung_N ;
|
|
defame_V2 = P.dirV2 (DictGer.diffamieren_V) ;
|
|
default_N = DictGer.standard_N ;
|
|
defeat_V2 = P.dirV2 (DictGer.besiegen_V) ;
|
|
defect_N = DictGer.defekt_N ;
|
|
defective_A = DictGer.defekt_A ;
|
|
defector_N = DictGer.ueberlaeufer_N ;
|
|
defend_V = DictGer.verteidigen_V ;
|
|
defend_V2 = P.dirV2 (DictGer.verteidigen_V) ;
|
|
defender_N = DictGer.verteidiger_N ;
|
|
defer_V = DictGer.verschieben_V ;
|
|
defer_V2 = P.dirV2 (DictGer.verschieben_V) ;
|
|
defiant_A = DictGer.trotzig_A ;
|
|
deficient_A = DictGer.mangelhaft_A ;
|
|
deficit_N = DictGer.defizit_N ;
|
|
define_V = DictGer.bestimmen_V ;
|
|
define_V2 = P.dirV2 (DictGer.bestimmen_V) ;
|
|
definition_N = DictGer.definition_N ;
|
|
deflation_N = DictGer.deflation_N ;
|
|
deflower_V2 = P.dirV2 (DictGer.deflorieren_V) ;
|
|
deforest_V2 = P.dirV2 (DictGer.entwalden_V) ;
|
|
defraud_V2 = P.dirV2 (DictGer.betruegen_V) ;
|
|
deft_A = DictGer.geschickt_A ;
|
|
defuse_V2 = P.dirV2 (DictGer.entschaerfen_V) ;
|
|
degeneration_N = DictGer.degeneration_N ;
|
|
degree_N = DictGer.ausmass_N ;
|
|
deist_N = DictGer.deist_N ;
|
|
deity_N = DictGer.gott_N ;
|
|
delay_N = DictGer.verzoegerung_N ;
|
|
delegate_N = DictGer.vertreter_N ;
|
|
delegation_N = DictGer.delegation_N ;
|
|
deliberate_A = DictGer.absichtlich_A ;
|
|
deliberation_N = DictGer.abwaegung_N ;
|
|
delicacy_N = DictGer.delikatesse_N ;
|
|
delicate_A = DictGer.empfindlich_A ;
|
|
delicious_A = DictGer.koestlich_A ;
|
|
delight_N = DictGer.entzueckung_N ;
|
|
delightful_A = DictGer.angenehm_A ;
|
|
delineate_V2 = P.dirV2 (DictGer.schildern_V) ;
|
|
delirium_N = DictGer.delirium_N ;
|
|
deliver_V = DictGer.befreien_V ;
|
|
deliver_V2 = P.dirV2 (DictGer.befreien_V) ;
|
|
deliverance_N = DictGer.erloesung_N ;
|
|
delivery_N = DictGer.geburt_N ;
|
|
deluge_N = DictGer.sintflut_N ;
|
|
delusion_N = DictGer.taeuschung_N ;
|
|
demagogic_A = DictGer.demagogisch_A ;
|
|
demagogue_N = DictGer.demagoge_N ;
|
|
demagogy_N = DictGer.demagogie_N ;
|
|
demand_N = DictGer.nachfrage_N ;
|
|
demarcation_N = DictGer.abgrenzung_N ;
|
|
demented_A = DictGer.dement_A ;
|
|
demerit_N = DictGer.nachteil_N ;
|
|
demigod_N = DictGer.halbgott_N ;
|
|
democracy_N = DictGer.demokratie_N ;
|
|
democratic_A = DictGer.demokratisch_A ;
|
|
demographic_A = DictGer.demographisch_A ;
|
|
demography_N = DictGer.demografie_N ;
|
|
demolition_N = DictGer.abbruch_N ;
|
|
demon_N = DictGer.daemon_N ;
|
|
demonic_A = DictGer.daemonisch_A ;
|
|
demonstrate_V = DictGer.demonstrieren_V ;
|
|
demonstrate_V2 = P.dirV2 (DictGer.demonstrieren_V) ;
|
|
demonstration_N = DictGer.demonstration_N ;
|
|
demote_V2 = P.dirV2 (DictGer.degradieren_V) ;
|
|
den_N = DictGer.hoehle_N ;
|
|
denial_N = DictGer.dementi_N ;
|
|
denigrate_V2 = P.dirV2 (DictGer.verleumden_V) ;
|
|
denizen_N = DictGer.bewohner_N ;
|
|
denomination_N = DictGer.benennung_N ;
|
|
denominator_N = DictGer.nenner_N ;
|
|
denote_V2 = P.dirV2 (DictGer.bedeuten_V) ;
|
|
denounce_V2 = P.dirV2 (DictGer.kuendigen_6_V) ;
|
|
density_N = DictGer.dichte_N ;
|
|
dent_N = DictGer.beule_N ;
|
|
dentist_N = DictGer.zahnarzt_N ;
|
|
denture_N = DictGer.gebiss_N ;
|
|
deny_V2 = P.dirV2 (DictGer.dementieren_V) ;
|
|
depart_V = DictGer.verlassen_V ;
|
|
department_N = DictGer.abteilung_N ;
|
|
departure_N = DictGer.abfahrt_N ;
|
|
dependable_A = DictGer.verlaesslich_A ;
|
|
dependence_N = DictGer.abhaengigkeit_N ;
|
|
dependency_N = DictGer.abhaengigkeit_N ;
|
|
dependent_A = DictGer.abhaengig_A ;
|
|
depiction_N = DictGer.darstellung_N ;
|
|
deplete_V2 = P.dirV2 (DictGer.dezimieren_V) ;
|
|
deplore_V2 = P.dirV2 (DictGer.bedauern_V) ;
|
|
deport_V2 = P.dirV2 (DictGer.deportieren_V) ;
|
|
deportation_N = DictGer.abschiebung_N ;
|
|
depose_V = DictGer.deponieren_V ;
|
|
depose_V2 = P.dirV2 (DictGer.deponieren_V) ;
|
|
deposit_N = DictGer.pfand_N ;
|
|
depot_N = DictGer.depot_N ;
|
|
depression_N = DictGer.depression_N ;
|
|
deprive_V2 = P.dirV2 (DictGer.verweigern_V) ;
|
|
depth_N = DictGer.tiefe_N ;
|
|
derby_N = DictGer.derby_N ;
|
|
derisive_A = DictGer.hoehnisch_A ;
|
|
derive_V = DictGer.erlangen_V ;
|
|
derive_V2 = P.dirV2 (DictGer.erlangen_V) ;
|
|
dermatologist_N = DictGer.dermatologe_N ;
|
|
derogatory_A = DictGer.abwertend_A ;
|
|
desalt_V2 = P.dirV2 (DictGer.entsalzen_V) ;
|
|
descent_N = DictGer.herkunft_N ;
|
|
describe_V = DictGer.beschreiben_V ;
|
|
describe_V2 = P.dirV2 (DictGer.beschreiben_V) ;
|
|
description_N = DictGer.beschreibung_N ;
|
|
descriptive_A = DictGer.deskriptiv_A ;
|
|
desecrate_V2 = P.dirV2 (DictGer.entweihen_V) ;
|
|
desert_N = DictGer.wueste_N ;
|
|
deserter_N = DictGer.deserteur_N ;
|
|
deserve_V = DictGer.verdienen_V ;
|
|
deserve_V2 = P.dirV2 (DictGer.verdienen_V) ;
|
|
design_N = DictGer.absicht_N ;
|
|
designation_N = DictGer.benennung_N ;
|
|
designer_N = DictGer.designer_N ;
|
|
desire_V2 = P.dirV2 (DictGer.begehren_0_V) ;
|
|
desk_N = DictGer.schreibtisch_N ;
|
|
desolate_A = DictGer.oede_A ;
|
|
despair_V = DictGer.verzweifeln_V ;
|
|
desperation_N = DictGer.verzweiflung_N ;
|
|
despondent_A = DictGer.mutlos_A ;
|
|
despot_N = DictGer.despot_N ;
|
|
despotic_A = DictGer.despotisch_A ;
|
|
dessert_N = DictGer.dessert_N ;
|
|
destination_N = DictGer.reiseziel_N ;
|
|
destiny_N = DictGer.schicksal_N ;
|
|
destroy_V2 = P.dirV2 (DictGer.loeschen_5_V) ;
|
|
destroyer_N = DictGer.zerstoerer_N ;
|
|
destruction_N = DictGer.vernichtung_N ;
|
|
destructive_A = DictGer.destruktiv_A ;
|
|
detach_V2 = P.dirV2 (DictGer.entfernen_V) ;
|
|
detail_N = DictGer.detail_N ;
|
|
detain_V2 = P.dirV2 (DictGer.verhaften_V) ;
|
|
detect_V2 = P.dirV2 (DictGer.entdecken_V) ;
|
|
detective_N = DictGer.detektiv_N ;
|
|
detector_N = DictGer.detektor_N ;
|
|
deteriorate_V = DictGer.verschlechtern_V ;
|
|
deteriorate_V2 = P.dirV2 (DictGer.verschlechtern_V) ;
|
|
determinant_N = DictGer.determinante_N ;
|
|
determination_N = DictGer.bestimmung_N ;
|
|
detest_V2 = P.dirV2 (DictGer.verabscheuen_V) ;
|
|
dethrone_V2 = P.dirV2 (DictGer.entthronen_V) ;
|
|
detonation_N = DictGer.detonation_N ;
|
|
detrimental_A = DictGer.schaedlich_A ;
|
|
devastate_V2 = P.dirV2 (DictGer.verwuesten_V) ;
|
|
devastation_N = DictGer.zerstoerung_N ;
|
|
develop_V = DictGer.entwickeln_V ;
|
|
develop_V2 = P.dirV2 (DictGer.entwickeln_V) ;
|
|
developer_N = DictGer.entwickler_N ;
|
|
development_N = DictGer.entwicklung_N ;
|
|
deviation_N = DictGer.abweichung_N ;
|
|
device_N = DictGer.apparat_N ;
|
|
devil_N = DictGer.satan_N ;
|
|
devilish_A = DictGer.teuflisch_A ;
|
|
devilry_N = DictGer.ulk_N ;
|
|
devise_V2 = P.dirV2 (DictGer.entwerfen_V) ;
|
|
devour_V2 = P.dirV2 (DictGer.fressen_V) ;
|
|
dexterity_N = DictGer.geschicklichkeit_N ;
|
|
dexterous_A = DictGer.behaend_A ;
|
|
dextrose_N = DictGer.dextrose_N ;
|
|
diabetes_N = DictGer.diabetes_N ;
|
|
diabolic_A = DictGer.diabolisch_A ;
|
|
diaeresis_N = DictGer.diaerese_N ;
|
|
diagnose_V2 = P.dirV2 (DictGer.diagnostizieren_V) ;
|
|
diagnosis_N = DictGer.diagnose_N ;
|
|
diagonal_A = DictGer.diagonal_A ;
|
|
diagram_N = DictGer.diagramm_N ;
|
|
dial_N = DictGer.waehlscheibe_N ;
|
|
dialect_N = DictGer.dialekt_N ;
|
|
dialectal_A = DictGer.dialektal_A ;
|
|
dialogue_N = DictGer.dialog_N ;
|
|
diameter_N = DictGer.durchmesser_N ;
|
|
diamond_N = DictGer.diamant_N ;
|
|
diaper_N = DictGer.windel_N ;
|
|
diaphanous_A = DictGer.diaphan_A ;
|
|
diaphragm_N = DictGer.diaphragma_N ;
|
|
diarrhea_N = DictGer.diarrhoe_N ;
|
|
diary_N = DictGer.tagebuch_N ;
|
|
dicey_A = DictGer.brenzlig_A ;
|
|
dichotomy_N = DictGer.dichotomie_N ;
|
|
dictate_N = DictGer.gebot_N ;
|
|
dictator_N = DictGer.diktator_N ;
|
|
dictatorial_A = DictGer.diktatorisch_A ;
|
|
dictatorship_N = DictGer.diktatur_N ;
|
|
dictionary_N = DictGer.woerterbuch_N ;
|
|
didactic_A = DictGer.didaktisch_A ;
|
|
die_V = LexiconGer.die_V ;
|
|
die_V2 = P.dirV2 (DictGer.sterben_2_V) ;
|
|
diesel_N = DictGer.diesel_N ;
|
|
diet_N = DictGer.diaet_N ;
|
|
difference_N = DictGer.differenz_N ;
|
|
different_A = DictGer.verschieden_A ;
|
|
differentiate_V = DictGer.differenzieren_V ;
|
|
differentiate_V2 = P.dirV2 (DictGer.differenzieren_V) ;
|
|
differentiation_N = DictGer.differentiation_N ;
|
|
difficult_A = DictGer.schwer_A ;
|
|
diffident_A = DictGer.schuechtern_A ;
|
|
diffraction_N = DictGer.beugung_N ;
|
|
diffusion_N = DictGer.diffusion_N ;
|
|
dig_V = LexiconGer.dig_V ;
|
|
dig_V2 = P.dirV2 (DictGer.graben_0_V) ;
|
|
digest_V = DictGer.verdauen_V ;
|
|
digest_V2 = P.dirV2 (DictGer.verdauen_V) ;
|
|
digit_N = DictGer.ziffer_N ;
|
|
digital_A = DictGer.digital_A ;
|
|
dignity_N = DictGer.wuerde_N ;
|
|
dike_N = DictGer.deich_N ;
|
|
dilapidation_N = DictGer.zerstoerung_N ;
|
|
dilatory_A = DictGer.langsam_A ;
|
|
dilettante_N = DictGer.amateur_N ;
|
|
diligent_A = DictGer.eifrig_A ;
|
|
dill_N = DictGer.dill_N ;
|
|
dilute_V = DictGer.verduennen_V ;
|
|
dilute_V2 = P.dirV2 (DictGer.verduennen_V) ;
|
|
dim_A = DictGer.daemlich_A ;
|
|
dimension_N = DictGer.dimension_N ;
|
|
diminish_V = DictGer.reduzieren_V ;
|
|
diminish_V2 = P.dirV2 (DictGer.reduzieren_V) ;
|
|
diminutive_A = DictGer.winzig_A ;
|
|
dimple_N = DictGer.beule_N ;
|
|
dine_V = DictGer.speisen_7_V ;
|
|
dine_V2 = P.dirV2 (DictGer.speisen_7_V) ;
|
|
dinghy_N = DictGer.jolle_N ;
|
|
dingy_A = DictGer.schmutzig_A ;
|
|
dinner_N = DictGer.hauptmahlzeit_N ;
|
|
dinosaur_N = DictGer.dinosaurier_N ;
|
|
diocese_N = DictGer.dioezese_N ;
|
|
dioxide_N = DictGer.dioxid_N ;
|
|
dip_N = DictGer.senke_N ;
|
|
diphtheria_N = DictGer.diphtherie_N ;
|
|
diphthong_N = DictGer.diphthong_N ;
|
|
diploma_N = DictGer.diplom_N ;
|
|
diplomat_N = DictGer.diplomat_N ;
|
|
diplomatic_A = DictGer.diplomatisch_A ;
|
|
dipper_N = DictGer.kelle_N ;
|
|
dipsomania_N = DictGer.dipsomanie_N ;
|
|
direct_A = DictGer.direkt_A ;
|
|
direction_N = DictGer.fuehrung_N ;
|
|
directive_N = DictGer.anordnung_N ;
|
|
directory_N = DictGer.ordner_N ;
|
|
dirigible_N = DictGer.luftschiff_N ;
|
|
dirt_N = DictGer.erde_N ;
|
|
dirty_A = LexiconGer.dirty_A ;
|
|
disability_N = DictGer.behinderung_N ;
|
|
disadvantage_N = DictGer.nachteil_N ;
|
|
disagreement_N = DictGer.streit_N ;
|
|
disappear_V = DictGer.verschwinden_V ;
|
|
disappoint_V2 = P.dirV2 (DictGer.enttaeuschen_V) ;
|
|
disappointed_A = DictGer.enttaeuscht_A ;
|
|
disappointment_N = DictGer.enttaeuschung_N ;
|
|
disarm_V = DictGer.entwaffnen_V ;
|
|
disarm_V2 = P.dirV2 (DictGer.entwaffnen_V) ;
|
|
disaster_N = DictGer.desaster_N ;
|
|
disastrous_A = DictGer.desastroes_A ;
|
|
disc_N = DictGer.bandscheibe_N ;
|
|
discard_V2 = P.dirV2 (DictGer.verwerfen_V) ;
|
|
discern_V2 = P.dirV2 (DictGer.erkennen_2_V) ;
|
|
discernment_N = DictGer.diskriminierung_N ;
|
|
discipline_N = DictGer.bestrafung_N ;
|
|
disco_N = DictGer.diskothek_N ;
|
|
discord_N = DictGer.dissonanz_N ;
|
|
discotheque_N = DictGer.diskothek_N ;
|
|
discourage_V2 = P.dirV2 (DictGer.entmutigen_V) ;
|
|
discourse_N = DictGer.diskurs_N ;
|
|
discover_V = DictGer.entdecken_V ;
|
|
discover_V2 = P.dirV2 (DictGer.entdecken_V) ;
|
|
discoverer_N = DictGer.entdecker_N ;
|
|
discovery_N = DictGer.entdeckung_N ;
|
|
discreet_A = DictGer.diskret_A ;
|
|
discrepancy_N = DictGer.diskrepanz_N ;
|
|
discrimination_N = DictGer.diskriminierung_N ;
|
|
discuss_V2 = P.dirV2 (DictGer.besprechen_V) ;
|
|
discussion_N = DictGer.diskussion_N ;
|
|
disdainful_A = DictGer.veraechtlich_A ;
|
|
disease_N = DictGer.krankheit_N ;
|
|
disequilibrium_N = DictGer.ungleichgewicht_N ;
|
|
disfigure_V2 = P.dirV2 (DictGer.verunstalten_V) ;
|
|
disgraceful_A = DictGer.schaendlich_A ;
|
|
disguise_N = DictGer.tarnung_N ;
|
|
disgusting_A = DictGer.ekelhaft_A ;
|
|
dish_N = DictGer.gericht_N ;
|
|
dishwasher_N = DictGer.geschirrspueler_N ;
|
|
disk_N = DictGer.scheibe_N ;
|
|
dislike_N = DictGer.unbehagen_N ;
|
|
dislocation_N = DictGer.luxation_N ;
|
|
dismiss_V2 = P.dirV2 (DictGer.entlassen_V) ;
|
|
dismissal_N = DictGer.entlassung_N ;
|
|
disorder_N = DictGer.stoerung_N ;
|
|
disparate_A = DictGer.disparat_A ;
|
|
disposal_N = DictGer.verfuegung_N ;
|
|
dispose_V = DictGer.beseitigen_V ;
|
|
dispose_V2 = P.dirV2 (DictGer.beseitigen_V) ;
|
|
disposition_N = DictGer.einteilung_N ;
|
|
disprove_V2 = P.dirV2 (DictGer.widerlegen_V) ;
|
|
dispute_N = DictGer.disput_N ;
|
|
disqualification_N = DictGer.disqualifikation_N ;
|
|
disrespect_N = DictGer.respektlosigkeit_N ;
|
|
disrespectful_A = DictGer.respektlos_A ;
|
|
disruption_N = DictGer.durcheinander_N ;
|
|
dissect_V2 = P.dirV2 (DictGer.sezieren_V) ;
|
|
dissemble_V = DictGer.verbergen_V ;
|
|
dissemble_V2 = P.dirV2 (DictGer.verbergen_V) ;
|
|
dissent_V = DictGer.dissentieren_V ;
|
|
dissertation_N = DictGer.dissertation_N ;
|
|
dissipate_V = DictGer.zerstreuen_V ;
|
|
dissipate_V2 = P.dirV2 (DictGer.zerstreuen_V) ;
|
|
dissonant_A = DictGer.dissonant_A ;
|
|
distance_N = DictGer.abstand_N ;
|
|
distant_A = DictGer.entfernt_A ;
|
|
distil_V = DictGer.destillieren_V ;
|
|
distil_V2 = P.dirV2 (DictGer.destillieren_V) ;
|
|
distillation_N = DictGer.destillation__N ;
|
|
distiller_N = DictGer.brenner_N ;
|
|
distillery_N = DictGer.brennerei_N ;
|
|
distinction_N = DictGer.auszeichnung_N ;
|
|
distinguish_V = DictGer.erkennen_2_V ;
|
|
distinguish_V2 = P.dirV2 (DictGer.erkennen_2_V) ;
|
|
distinguishable_A = DictGer.differenzierbar_A ;
|
|
distraction_N = DictGer.ablenkung_N ;
|
|
distraught_A = DictGer.angetan_A ;
|
|
distribute_V2 = P.dirV2 (DictGer.beliefern_V) ;
|
|
distribution_N = DictGer.absatz_N ;
|
|
disturb_V2 = P.dirV2 (DictGer.stoeren_V) ;
|
|
ditch_V = DictGer.notwassern_V ;
|
|
ditch_V2 = P.dirV2 (DictGer.notwassern_V) ;
|
|
diurnal_A = DictGer.taeglich_A ;
|
|
dive_V = DictGer.tauchen_7_V ;
|
|
diver_N = DictGer.seetaucher_N ;
|
|
diverge_V = DictGer.divergieren_V ;
|
|
diverse_A = DictGer.unterschiedlich_A ;
|
|
diversion_N = DictGer.ablenkung_N ;
|
|
diversity_N = DictGer.mannigfaltigkeit_N ;
|
|
divest_V2 = P.dirV2 (DictGer.entziehen_V) ;
|
|
divide_V = DictGer.dividieren_V ;
|
|
divide_V2 = P.dirV2 (DictGer.dividieren_V) ;
|
|
dividend_N = DictGer.dividend_N ;
|
|
divine_A = DictGer.goettlich_A ;
|
|
divisible_A = DictGer.teilbar_A ;
|
|
division_N = DictGer.abteilung_N ;
|
|
divisor_N = DictGer.divisor_N ;
|
|
divorce_N = DictGer.scheidung_N ;
|
|
divulge_V2 = P.dirV2 (DictGer.enthuellen_V) ;
|
|
dizzy_A = DictGer.schwindelig_A ;
|
|
do_V2 = LexiconGer.do_V2 ;
|
|
dobbin_N = DictGer.maehre_N ;
|
|
dockyard_N = DictGer.werft_N ;
|
|
doctor_N = LexiconGer.doctor_N ;
|
|
doctorate_N = DictGer.doktorgrad_N ;
|
|
doctrine_N = DictGer.doktrin_N ;
|
|
document_N = DictGer.dokument_N ;
|
|
documentation_N = DictGer.dokumentation_N ;
|
|
dog_N = LexiconGer.dog_N ;
|
|
doge_N = DictGer.doge_N ;
|
|
doghouse_N = DictGer.hundehuette_N ;
|
|
dogmatic_A = DictGer.dogmatisch_A ;
|
|
doll_N = DictGer.puppe_N ;
|
|
dolphin_N = DictGer.delfin_N ;
|
|
domain_N = DictGer.bereich_N ;
|
|
domesticate_V2 = P.dirV2 (DictGer.domestizieren_V) ;
|
|
domicile_N = DictGer.domizil_N ;
|
|
dominance_N = DictGer.dominanz_N ;
|
|
dominate_V = DictGer.dominieren_V ;
|
|
dominate_V2 = P.dirV2 (DictGer.dominieren_V) ;
|
|
don_N = DictGer.professor_N ;
|
|
donate_V = DictGer.schenken_1_V ;
|
|
donate_V2 = P.dirV2 (DictGer.schenken_1_V) ;
|
|
donation_N = DictGer.abgabe_N ;
|
|
donjon_N = DictGer.donjon_N ;
|
|
donkey_N = DictGer.esel_N ;
|
|
donor_N = DictGer.spender_N ;
|
|
doom_N = DictGer.untergang_N ;
|
|
door_N = LexiconGer.door_N ;
|
|
dormer_N = DictGer.dachgaube_N ;
|
|
dormitory_N = DictGer.heim_N ;
|
|
dormouse_N = DictGer.bilch_N ;
|
|
dorsal_A = DictGer.dorsal_A ;
|
|
dose_N = DictGer.dosis_N ;
|
|
dossier_N = DictGer.akte_N ;
|
|
dot_N = DictGer.punkt_N ;
|
|
dote_V = DictGer.schwaermen_V ;
|
|
double_A = DictGer.doppelt_A ;
|
|
doubt_V2 = P.dirV2 (DictGer.zweifeln_2_V) ;
|
|
doubtful_A = DictGer.zweifelhaft_A ;
|
|
douche_N = DictGer.dusche_N ;
|
|
dough_N = DictGer.knete_N ;
|
|
doughnut_N = DictGer.donut_N ;
|
|
dove_N = DictGer.taube_N ;
|
|
dovetail_N = DictGer.verzahnung_N ;
|
|
dowel_N = DictGer.duebel_N ;
|
|
down_N = DictGer.daune_N ;
|
|
downfall_N = DictGer.niedergang_N ;
|
|
downpour_N = DictGer.regenguss_N ;
|
|
downtrodden_A = DictGer.unterdrueckt_A ;
|
|
dowry_N = DictGer.mitgift_N ;
|
|
doxology_N = DictGer.doxologie_N ;
|
|
dozen_N = DictGer.dutzend_N ;
|
|
drachma_N = DictGer.drachme_N ;
|
|
draconian_A = DictGer.drakonisch_A ;
|
|
draft_N = DictGer.entwurf_N ;
|
|
dragoman_N = DictGer.dolmetscher_N ;
|
|
dragon_N = DictGer.drache_N ;
|
|
dragonfly_N = DictGer.libelle_N ;
|
|
drain_N = DictGer.abfluss_N ;
|
|
drake_N = DictGer.enterich_N ;
|
|
drama_N = DictGer.drama_N ;
|
|
dramatic_A = DictGer.dramatisch_A ;
|
|
drastic_A = DictGer.drastisch_A ;
|
|
draught_N = DictGer.zug_N ;
|
|
draughts_N = DictGer.dame_N ;
|
|
draw_V = DictGer.zeichnen_1_V ;
|
|
draw_V2 = P.dirV2 (DictGer.zeichnen_1_V) ;
|
|
drawback_N = DictGer.nachteil_N ;
|
|
drawbridge_N = DictGer.zugbruecke_N ;
|
|
drawer_N = DictGer.schublade_N ;
|
|
dread_V = DictGer.befuerchten_V ;
|
|
dread_V2 = P.dirV2 (DictGer.befuerchten_V) ;
|
|
dreadful_A = DictGer.furchtbar_A ;
|
|
dream_N = DictGer.traum_N ;
|
|
dreamy_A = DictGer.versonnen_A ;
|
|
dress_N = DictGer.kleidung_N ;
|
|
dribble_V = DictGer.dribbeln_V ;
|
|
dribble_V2 = P.dirV2 (DictGer.dribbeln_V) ;
|
|
drill_V = DictGer.bohren_V ;
|
|
drill_V2 = P.dirV2 (DictGer.bohren_V) ;
|
|
drink_V = DictGer.saufen_V ;
|
|
drink_V2 = LexiconGer.drink_V2 ;
|
|
drinkable_A = DictGer.trinkbar_A ;
|
|
drip_V = DictGer.lecken_V ;
|
|
drip_V2 = P.dirV2 (DictGer.lecken_V) ;
|
|
drive_V = DictGer.fahren_7_V ;
|
|
drive_V2 = P.dirV2 (DictGer.fahren_7_V) ;
|
|
driver_N = DictGer.fahrer_N ;
|
|
driveway_N = DictGer.auffahrt_N ;
|
|
droll_A = DictGer.drollig_A ;
|
|
drone_N = DictGer.drohne_N ;
|
|
drool_V = DictGer.sabbern_V ;
|
|
drop_N = DictGer.abfall_N ;
|
|
droshky_N = DictGer.droschke_N ;
|
|
drought_N = DictGer.duerre_N ;
|
|
drown_V = DictGer.ertrinken_V ;
|
|
drown_V2 = P.dirV2 (DictGer.ertrinken_V) ;
|
|
drowsy_A = DictGer.schlaefrig_A ;
|
|
drug_N = DictGer.droge_N ;
|
|
druid_N = DictGer.druide_N ;
|
|
drum_N = DictGer.fass_N ;
|
|
drummer_N = DictGer.schlagzeuger_N ;
|
|
drumstick_N = DictGer.haehnchenkeule_N ;
|
|
drunk_A = DictGer.besoffen_A ;
|
|
drunkard_N = DictGer.saeufer_N ;
|
|
drunken_A = DictGer.betrunken_A ;
|
|
dry_A = LexiconGer.dry_A ;
|
|
dryer_N = DictGer.trockner_N ;
|
|
dubious_A = DictGer.dubios_A ;
|
|
duck_N = DictGer.ente_N ;
|
|
dud_N = DictGer.blindgaenger_N ;
|
|
dude_N = DictGer.alter_N ;
|
|
due_A = DictGer.faellig_A ;
|
|
duel_N = DictGer.duell_N ;
|
|
duet_N = DictGer.duett_N ;
|
|
duke_N = DictGer.herzog_N ;
|
|
dulcet_A = DictGer.angenehm_A ;
|
|
dull_A = LexiconGer.dull_A ;
|
|
dumb_A = DictGer.dumm_A ;
|
|
dumbbell_N = DictGer.hantel_N ;
|
|
dummy_N = DictGer.attrappe_N ;
|
|
dumpling_N = DictGer.knoedel_N ;
|
|
dune_N = DictGer.duene_N ;
|
|
dungeon_N = DictGer.kerker_N ;
|
|
duodenum_N = DictGer.duodenum_N ;
|
|
duration_N = DictGer.dauer_N ;
|
|
dusk_N = DictGer.abenddaemmerung_N ;
|
|
dust_N = LexiconGer.dust_N ;
|
|
dustbin_N = DictGer.muelleimer_N ;
|
|
duster_N = DictGer.staublappen_N ;
|
|
dustpan_N = DictGer.kutterschaufel_N ;
|
|
dusty_A = DictGer.staubig_A ;
|
|
dutch_A = DictGer.hollaendisch_A ;
|
|
duty_N = DictGer.arbeitszeit_N ;
|
|
dwarf_N = DictGer.zwerg_N ;
|
|
dwelling_N = DictGer.wohnsitz_N ;
|
|
dwindle_V = DictGer.schwinden_V ;
|
|
dyer_N = DictGer.faerber_N ;
|
|
dynamic_A = DictGer.dynamisch_A ;
|
|
dynamite_N = DictGer.sprengstoff_N ;
|
|
dynamo_N = DictGer.dynamo_N ;
|
|
dynastic_A = DictGer.dynastisch_A ;
|
|
dynasty_N = DictGer.dynastie_N ;
|
|
ear_N = LexiconGer.ear_N ;
|
|
earl_N = DictGer.graf_N ;
|
|
early_A = DictGer.frueh_A ;
|
|
earn_V = DictGer.verdienen_V ;
|
|
earn_V2 = P.dirV2 (DictGer.verdienen_V) ;
|
|
earphone_N = DictGer.ohrhoerer_N ;
|
|
earring_N = DictGer.ohrring_N ;
|
|
earth_N = LexiconGer.earth_N ;
|
|
earthquake_N = DictGer.erdbeben_N ;
|
|
earthworm_N = DictGer.regenwurm_N ;
|
|
earwig_N = DictGer.ohrwurm_N ;
|
|
ease_N = DictGer.bequemlichkeit_N ;
|
|
eastern_A = DictGer.oestlich_A ;
|
|
easy_A = DictGer.einfach_A ;
|
|
eat_V = DictGer.essen_4_V ;
|
|
eat_V2 = LexiconGer.eat_V2 ;
|
|
ebb_N = DictGer.ebbe_N ;
|
|
ebony_N = DictGer.ebenholz_N ;
|
|
eccentric_A = DictGer.exzentrisch_A ;
|
|
ecclesiastical_A = DictGer.sakral_A ;
|
|
echo_N = DictGer.echo_N ;
|
|
ecliptic_N = DictGer.ekliptik_N ;
|
|
ecological_A = DictGer.oekologisch_A ;
|
|
ecologist_N = DictGer.oekologe_N ;
|
|
economic_A = DictGer.oekonomisch_A ;
|
|
economical_A = DictGer.sparsam_A ;
|
|
economics_N = DictGer.wirtschaftswissenschaft_N ;
|
|
economist_N = DictGer.oekonom_N ;
|
|
economy_N = DictGer.wirtschaft_N ;
|
|
ecosystem_N = DictGer.oekosystem_N ;
|
|
ecstatic_A = DictGer.ekstatisch_A ;
|
|
eczema_N = DictGer.ekzem_N ;
|
|
eddy_N = DictGer.wirbel_N ;
|
|
edelweiss_N = DictGer.edelweiss_N ;
|
|
edge_N = DictGer.kante_N ;
|
|
edible_A = DictGer.essbar_A ;
|
|
edict_N = DictGer.edikt_N ;
|
|
edifice_N = DictGer.bauwerk_N ;
|
|
edition_N = DictGer.aufgabe_N ;
|
|
education_N = DictGer.aufklaerung_N ;
|
|
eel_N = DictGer.aal_N ;
|
|
eerie_A = DictGer.unheimlich_A ;
|
|
effect_N = DictGer.auswirkung_N ;
|
|
effective_A = DictGer.wirksam_A ;
|
|
effectiveness_N = DictGer.efficacy_N ;
|
|
effeminate_A = DictGer.weibisch_A ;
|
|
efficacy_N = DictGer.efficacy_N ;
|
|
efficient_A = DictGer.effizient_A ;
|
|
effort_N = DictGer.anstrengung_N ;
|
|
effusive_A = DictGer.ueberschwaenglich_A ;
|
|
egalitarian_A = DictGer.egalitaer_A ;
|
|
egg_N = LexiconGer.egg_N ;
|
|
eggplant_N = DictGer.aubergine_N ;
|
|
eggshell_N = DictGer.eierschale_N ;
|
|
ego_N = DictGer.ego_N ;
|
|
egocentric_A = DictGer.egozentrisch_A ;
|
|
egoism_N = DictGer.egoismus_N ;
|
|
egoist_N = DictGer.egoist_N ;
|
|
egoistic_A = DictGer.egoistisch_A ;
|
|
ejaculate_V2 = P.dirV2 (DictGer.ejakulieren_V) ;
|
|
ejaculation_N = DictGer.ejakulation_N ;
|
|
elapse_V = DictGer.vergehen_V ;
|
|
elation_N = DictGer.begeisterung_N ;
|
|
elbow_N = DictGer.ellbogen_N ;
|
|
election_N = DictGer.wahl_N ;
|
|
electric_A = DictGer.elektrisch_A ;
|
|
electrician_N = DictGer.elektriker_N ;
|
|
electrode_N = DictGer.elektrode_N ;
|
|
electrolysis_N = DictGer.elektrolyse_N ;
|
|
electromagnet_N = DictGer.elektromagnet_N ;
|
|
electron_N = DictGer.elektron_N ;
|
|
electronic_A = DictGer.elektronisch_A ;
|
|
elegant_A = DictGer.elegant_A ;
|
|
elegy_N = DictGer.elegie_N ;
|
|
element_N = DictGer.bauelement_N ;
|
|
elephant_N = DictGer.elefant_N ;
|
|
elf_N = DictGer.alb_N ;
|
|
eliminate_V2 = P.dirV2 (DictGer.eliminieren_V) ;
|
|
elimination_N = DictGer.elimination_N ;
|
|
elision_N = DictGer.elision_N ;
|
|
elixir_N = DictGer.elixier_N ;
|
|
elk_N = DictGer.elch_N ;
|
|
ellipse_N = DictGer.ellipse_N ;
|
|
ellipsis_N = DictGer.ellipse_N ;
|
|
elm_N = DictGer.ulme_N ;
|
|
eloquent_A = DictGer.eloquent_A ;
|
|
embargo_N = DictGer.embargo_N ;
|
|
embassy_N = DictGer.botschaft_N ;
|
|
embellish_V2 = P.dirV2 (DictGer.schmuecken_4_V) ;
|
|
embodiment_N = DictGer.inbegriff_N ;
|
|
embrace_V = DictGer.umarmen_V ;
|
|
embrace_V2 = P.dirV2 (DictGer.umarmen_V) ;
|
|
embrasure_N = DictGer.scharte_N ;
|
|
embroider_V = DictGer.sticken_2_V ;
|
|
embroider_V2 = P.dirV2 (DictGer.sticken_2_V) ;
|
|
embryo_N = DictGer.embryo_N ;
|
|
embryonic_A = DictGer.embryonal_A ;
|
|
emend_V2 = P.dirV2 (DictGer.emendieren_V) ;
|
|
emergence_N = DictGer.emergenz_N ;
|
|
emergency_N = DictGer.notfall_N ;
|
|
emigrant_N = DictGer.auswanderer_N ;
|
|
emigration_N = DictGer.auswanderung_N ;
|
|
eminent_A = DictGer.angesehen_A ;
|
|
emirate_N = DictGer.emirat_N ;
|
|
emissary_N = DictGer.emissaer_N ;
|
|
emission_N = DictGer.emission_N ;
|
|
emit_V2 = P.dirV2 (DictGer.emittieren_V) ;
|
|
emolument_N = DictGer.honorar_N ;
|
|
emotion_N = DictGer.emotion_N ;
|
|
emotional_A = DictGer.emotional_A ;
|
|
emperor_N = DictGer.kaiser_N ;
|
|
emphasis_N = DictGer.betonung_N ;
|
|
emphasize_V2 = P.dirV2 (DictGer.betonen_V) ;
|
|
emphatic_A = DictGer.emphatisch_A ;
|
|
empire_N = DictGer.imperium_N ;
|
|
empirical_A = DictGer.empirisch_A ;
|
|
employer_N = DictGer.arbeitgeber_N ;
|
|
employment_N = DictGer.anstellung_N ;
|
|
empress_N = DictGer.kaiserin_N ;
|
|
empty_A = LexiconGer.empty_A ;
|
|
emu_N = DictGer.emu_N ;
|
|
emulsion_N = DictGer.emulsion_N ;
|
|
enable_V2 = P.dirV2 (DictGer.aktivieren_V) ;
|
|
enamel_N = DictGer.email_N ;
|
|
encephalitis_N = DictGer.enzephalitis_N ;
|
|
enclave_N = DictGer.enklave_N ;
|
|
enclosure_N = DictGer.anlage_N ;
|
|
encompass_V2 = P.dirV2 (DictGer.umfassen_V) ;
|
|
encore_N = DictGer.zugabe_N ;
|
|
encounter_V2 = P.dirV2 (DictGer.begegnen_V) ;
|
|
encourage_V2 = P.dirV2 (DictGer.empfehlen_V) ;
|
|
encrypt_V2 = P.dirV2 (DictGer.verschluesseln_V) ;
|
|
encyclical_N = DictGer.enzyklika_N ;
|
|
encyclopaedia_N = DictGer.enzyklopaedie_N ;
|
|
encyclopedia_N = DictGer.enzyklopaedie_N ;
|
|
end_N = DictGer.ende_N ;
|
|
endanger_V2 = P.dirV2 (DictGer.gefaehrden_V) ;
|
|
endemic_A = DictGer.endemisch_A ;
|
|
endless_A = DictGer.endlos_A ;
|
|
endorse_V2 = P.dirV2 (DictGer.bestaetigen_V) ;
|
|
endurable_A = DictGer.ertraeglich_A ;
|
|
endure_V = DictGer.dulden_V ;
|
|
endure_V2 = P.dirV2 (DictGer.dulden_V) ;
|
|
enema_N = DictGer.einlauf_N ;
|
|
enemy_N = LexiconGer.enemy_N ;
|
|
energetic_A = DictGer.energisch_A ;
|
|
energy_N = DictGer.energie__N ;
|
|
engagement_N = DictGer.gefecht_N ;
|
|
engender_V2 = P.dirV2 (DictGer.erzeugen_V) ;
|
|
engine_N = DictGer.antrieb_N ;
|
|
engineer_N = DictGer.ingenieur_N ;
|
|
english_A = DictGer.englisch_A ;
|
|
enigma_N = DictGer.raetsel_N ;
|
|
enjoy_V2 = P.dirV2 (DictGer.geniessen_V) ;
|
|
enlarge_V = DictGer.vergroessern_V ;
|
|
enlarge_V2 = P.dirV2 (DictGer.vergroessern_V) ;
|
|
enlargement_N = DictGer.vergroesserung_N ;
|
|
enlightenment_N = DictGer.aufklaerung_N ;
|
|
ennui_N = DictGer.apathie_N ;
|
|
enroll_V = DictGer.immatrikulieren_V ;
|
|
enroll_V2 = P.dirV2 (DictGer.immatrikulieren_V) ;
|
|
enrolment_N = DictGer.anmeldung_N ;
|
|
ensemble_N = DictGer.ensemble_N ;
|
|
ensign_N = DictGer.fahne_N ;
|
|
enslave_V2 = P.dirV2 (DictGer.versklaven_V) ;
|
|
ensue_V = DictGer.erfolgen_V ;
|
|
ensure_V = DictGer.gewaehrleisten_V ;
|
|
ensure_V2 = P.dirV2 (DictGer.gewaehrleisten_V) ;
|
|
enter_V = DictGer.betreten_V ;
|
|
enter_V2 = P.dirV2 (DictGer.betreten_V) ;
|
|
enterprise_N = DictGer.unterfangen_N ;
|
|
entertain_V2 = P.dirV2 (DictGer.unterhalten_V) ;
|
|
entertainment_N = DictGer.unterhaltung_N ;
|
|
enthronement_N = DictGer.inthronisation_N ;
|
|
enthuse_V = DictGer.begeistern_V ;
|
|
enthusiasm_N = DictGer.begeisterung_N ;
|
|
enthusiastic_A = DictGer.enthusiastisch_A ;
|
|
entitle_V2 = P.dirV2 (DictGer.benennen_V) ;
|
|
entitlement_N = DictGer.anspruch_N ;
|
|
entourage_N = DictGer.gefolge_N ;
|
|
entrance_N = DictGer.einfahrt_N ;
|
|
entrepreneur_N = DictGer.unternehmer_N ;
|
|
entry_N = DictGer.eingang_N ;
|
|
envelope_N = DictGer.briefumschlag_N ;
|
|
enviable_A = DictGer.beneidenswert_A ;
|
|
envious_A = DictGer.neidisch_A ;
|
|
environment_N = DictGer.umfeld_N ;
|
|
enzyme_N = DictGer.enzym_N ;
|
|
eon_N = DictGer.aeon_N ;
|
|
epaulet_N = DictGer.epaulette_N ;
|
|
epic_N = DictGer.epos_N ;
|
|
epicentre_N = DictGer.epizentrum_N ;
|
|
epidemic_N = DictGer.epidemie_N ;
|
|
epigram_N = DictGer.epigramm_N ;
|
|
epilepsy_N = DictGer.epilepsie_N ;
|
|
episode_N = DictGer.episode_N ;
|
|
epitaph_N = DictGer.epitaph_N ;
|
|
epithet_N = DictGer.beiwort_N ;
|
|
epitome_N = DictGer.abriss_N ;
|
|
epoch_N = DictGer.epoche_N ;
|
|
equality_N = DictGer.gleichheit_N ;
|
|
equation_N = DictGer.gleichung_N ;
|
|
equator_N = DictGer.aequator_N ;
|
|
equatorial_A = DictGer.aequatorial_A ;
|
|
equilibrium_N = DictGer.balance_N ;
|
|
equinox_N = DictGer.tagundnachtgleiche_N ;
|
|
equipage_N = DictGer.ausruestung_N ;
|
|
equipment_N = DictGer.ausruestung_N ;
|
|
equitable_A = DictGer.ehrlich_A ;
|
|
equivalence_N = DictGer.aequivalenz_N ;
|
|
equivalent_A = DictGer.gleichwertig_A ;
|
|
era_N = DictGer.epoche_N ;
|
|
erection_N = DictGer.erektion_N ;
|
|
eremite_N = DictGer.einsiedler_N ;
|
|
ergonomics_N = DictGer.ergonomie_N ;
|
|
ermine_N = DictGer.hermelin_N ;
|
|
erosion_N = DictGer.erosion_N ;
|
|
erotic_A = DictGer.erotisch_A ;
|
|
err_V = DictGer.irren_V ;
|
|
errand_N = DictGer.besorgung_N ;
|
|
erratic_A = DictGer.erratisch_A ;
|
|
erratum_N = DictGer.erratum_N ;
|
|
erroneous_A = DictGer.unrichtig_A ;
|
|
error_N = DictGer.fehler_N ;
|
|
eruption_N = DictGer.ausbruch_N ;
|
|
escalate_V = DictGer.eskalieren_V ;
|
|
escalate_V2 = P.dirV2 (DictGer.eskalieren_V) ;
|
|
escalation_N = DictGer.eskalation_N ;
|
|
escalator_N = DictGer.rolltreppe_N ;
|
|
escapade_N = DictGer.eskapade_N ;
|
|
escape_V = DictGer.entgehen_V ;
|
|
escape_V2 = P.dirV2 (DictGer.entgehen_V) ;
|
|
escapism_N = DictGer.eskapismus_N ;
|
|
escarpment_N = DictGer.boeschung_N ;
|
|
eschatology_N = DictGer.eschatologie_N ;
|
|
eschew_V2 = P.dirV2 (DictGer.meiden_V) ;
|
|
escort_N = DictGer.eskorte_N ;
|
|
esoteric_A = DictGer.geheim_A ;
|
|
essay_N = DictGer.aufsatz_N ;
|
|
establish_V2 = P.dirV2 (DictGer.begruenden_V) ;
|
|
estate_N = DictGer.gut_N ;
|
|
esteem_N = DictGer.ansehen_N ;
|
|
estimate_N = DictGer.abschaetzung_N ;
|
|
etch_V = DictGer.radieren_V ;
|
|
etch_V2 = P.dirV2 (DictGer.radieren_V) ;
|
|
eternal_A = DictGer.ewig_A ;
|
|
eternity_N = DictGer.ewigkeit_N ;
|
|
ether_N = DictGer.ether_N ;
|
|
ethereal_A = DictGer.aetherisch_A ;
|
|
ethical_A = DictGer.ethisch_A ;
|
|
ethnic_A = DictGer.ethnisch_A ;
|
|
etiquette_N = DictGer.etikette_N ;
|
|
etymological_A = DictGer.etymologisch_A ;
|
|
etymologist_N = DictGer.etymologe_N ;
|
|
etymology_N = DictGer.etymologie_N ;
|
|
eulogy_N = DictGer.lobrede_N ;
|
|
euphemism_N = DictGer.euphemismus_N ;
|
|
euphonium_N = DictGer.euphonium_N ;
|
|
euphoria_N = DictGer.euphorie_N ;
|
|
european_A = DictGer.europaeisch_A ;
|
|
euthanasia_N = DictGer.sterbehilfe_N ;
|
|
evacuation_N = DictGer.evakuierung_N ;
|
|
evaluate_V = DictGer.evaluieren_V ;
|
|
evaluate_V2 = P.dirV2 (DictGer.evaluieren_V) ;
|
|
evaluation_N = DictGer.beurteilung_N ;
|
|
eve_N = DictGer.vorabend_N ;
|
|
even_A = DictGer.eben_A ;
|
|
evening_N = DictGer.abend_N ;
|
|
event_N = DictGer.ereignis_N ;
|
|
evergreen_A = DictGer.immergruen_A ;
|
|
everyday_A = DictGer.alltaeglich_A ;
|
|
evict_V2 = P.dirV2 (DictGer.vertreiben_V) ;
|
|
eviction_N = DictGer.raeumung_N ;
|
|
evidence_N = DictGer.beweis_N ;
|
|
evil_A = DictGer.boese_A ;
|
|
evolution_N = DictGer.evolution_N ;
|
|
ewer_N = DictGer.krug_N ;
|
|
exacerbate_V2 = P.dirV2 (DictGer.erbittern_V) ;
|
|
exact_A = DictGer.exakt_A ;
|
|
exaggerate_V = DictGer.uebertreiben_V ;
|
|
exaggerate_V2 = P.dirV2 (DictGer.uebertreiben_V) ;
|
|
exaggeration_N = DictGer.uebertreibung_N ;
|
|
examine_V2 = P.dirV2 (DictGer.befragen_V) ;
|
|
example_N = DictGer.beispiel_N ;
|
|
excavator_N = DictGer.bagger_N ;
|
|
excel_V = DictGer.uebersteigen_V ;
|
|
excel_V2 = P.dirV2 (DictGer.uebersteigen_V) ;
|
|
excellent_A = DictGer.ausgezeichnet_A ;
|
|
exception_N = DictGer.ausnahme_N ;
|
|
exceptional_A = DictGer.aussergewoehnlich_A ;
|
|
excerpt_N = DictGer.auszug_N ;
|
|
excessive_A = DictGer.exzessiv_A ;
|
|
exchange_N = DictGer.austausch_N ;
|
|
excite_V2 = P.dirV2 (DictGer.erregen_V) ;
|
|
excitement_N = DictGer.aufregung_N ;
|
|
exclamation_N = DictGer.exklamation_N ;
|
|
exclusive_A = DictGer.ausschliesslich_A ;
|
|
excursion_N = DictGer.ausflug_N ;
|
|
excuse_V2 = P.dirV2 (DictGer.entschuldigen_V) ;
|
|
execution_N = DictGer.ausfuehrung_N ;
|
|
executioner_N = DictGer.henker_N ;
|
|
exegesis_N = DictGer.exegese_N ;
|
|
exercise_N = DictGer.training_N ;
|
|
exhibition_N = DictGer.ausstellung_N ;
|
|
exhibitionist_N = DictGer.exhibitionist_N ;
|
|
exhume_V2 = P.dirV2 (DictGer.exhumieren_V) ;
|
|
exile_N = DictGer.exil_N ;
|
|
exist_V = DictGer.bestehen_V ;
|
|
existence_N = DictGer.existenz_N ;
|
|
exit_N = DictGer.abtritt_N ;
|
|
exodus_N = DictGer.exodus_N ;
|
|
exorbitant_A = DictGer.exorbitant_A ;
|
|
expand_V = DictGer.expandieren_V ;
|
|
expand_V2 = P.dirV2 (DictGer.expandieren_V) ;
|
|
expansion_N = DictGer.expansion_N ;
|
|
expectation_N = DictGer.erwartung_N ;
|
|
expedite_V2 = P.dirV2 (DictGer.beschleunigen_V) ;
|
|
expel_V2 = P.dirV2 (DictGer.deportieren_V) ;
|
|
expense_N = DictGer.verlust_N ;
|
|
experience_N = DictGer.erfahrung_N ;
|
|
experiment_N = DictGer.experiment_N ;
|
|
experimental_A = DictGer.experimentell_A ;
|
|
expertise_N = DictGer.expertise_N ;
|
|
expire_V = DictGer.erloeschen_V ;
|
|
expire_V2 = P.dirV2 (DictGer.erloeschen_V) ;
|
|
expiry_N = DictGer.ablauf_N ;
|
|
explain_V2 = P.dirV2 (DictGer.erklaeren_V) ;
|
|
explanation_N = DictGer.ausfuehrung_N ;
|
|
explicate_V2 = P.dirV2 (DictGer.explizieren_V) ;
|
|
explicit_A = DictGer.ausdruecklich_A ;
|
|
explode_V = DictGer.explodieren_V ;
|
|
explode_V2 = P.dirV2 (DictGer.explodieren_V) ;
|
|
exploration_N = DictGer.untersuchung_N ;
|
|
explorer_N = DictGer.forscher_N ;
|
|
explosion_N = DictGer.explosion_N ;
|
|
explosive_N = DictGer.sprengstoff_N ;
|
|
exponential_A = DictGer.exponentiell_A ;
|
|
exporter_N = DictGer.exporteur_N ;
|
|
expose_V = DictGer.offenbaren_V ;
|
|
expose_V2 = P.dirV2 (DictGer.offenbaren_V) ;
|
|
exposition_N = DictGer.ausstellung_N ;
|
|
exposure_N = DictGer.einwirkung_N ;
|
|
express_A = DictGer.ausdruecklich_A ;
|
|
expression_N = DictGer.redensart_N ;
|
|
expressionless_A = DictGer.ausdruckslos_A ;
|
|
expressway_N = DictGer.autobahn_N ;
|
|
expropriation_N = DictGer.enteignung_N ;
|
|
expulsion_N = DictGer.entfernung_N ;
|
|
exquisite_A = DictGer.exquisit_A ;
|
|
extemporize_V = DictGer.extemporieren_V ;
|
|
extemporize_V2 = P.dirV2 (DictGer.extemporieren_V) ;
|
|
extend_V = DictGer.erweitern_V ;
|
|
extend_V2 = P.dirV2 (DictGer.erweitern_V) ;
|
|
extension_N = DictGer.ausdehnung_N ;
|
|
extensive_A = DictGer.umfangreich_A ;
|
|
extent_N = DictGer.ausmass_N ;
|
|
external_A = DictGer.extern_A ;
|
|
extinguish_V2 = P.dirV2 (DictGer.loeschen_5_V) ;
|
|
extortion_N = DictGer.erpressung_N ;
|
|
extradition_N = DictGer.auslieferung_N ;
|
|
extraordinary_A = DictGer.aussergewoehnlich_A ;
|
|
extravagant_A = DictGer.extravagant_A ;
|
|
extreme_A = DictGer.extrem_A ;
|
|
extremist_N = DictGer.extremist_N ;
|
|
extremity_N = DictGer.extremitaet_N ;
|
|
exuberant_A = DictGer.ausgelassen_A ;
|
|
exult_V = DictGer.jauchzen_V ;
|
|
eye_N = LexiconGer.eye_N ;
|
|
eyeball_N = DictGer.augapfel_N ;
|
|
eyebrow_N = DictGer.augenbraue_N ;
|
|
eyeglass_N = DictGer.augenglas_N ;
|
|
eyelash_N = DictGer.wimper_N ;
|
|
eyelet_N = DictGer.oese_N ;
|
|
eyelid_N = DictGer.augenlid_N ;
|
|
eyewitness_N = DictGer.augenzeuge_N ;
|
|
eyrie_N = DictGer.adlerhorst_N ;
|
|
fable_N = DictGer.fabel_N ;
|
|
fabric_N = DictGer.gewebe_N ;
|
|
fabricate_V2 = P.dirV2 (DictGer.erzeugen_V) ;
|
|
fabulous_A = DictGer.fabelhaft_A ;
|
|
facade_N = DictGer.fassade_N ;
|
|
face_N = DictGer.antlitz_N ;
|
|
facet_N = DictGer.facette_N ;
|
|
facilitate_V2 = P.dirV2 (DictGer.erleichtern_V) ;
|
|
facility_N = DictGer.einrichtung_N ;
|
|
fact_N = DictGer.faktum_N ;
|
|
faction_N = DictGer.fraktion_N ;
|
|
factor_N = DictGer.faktor_N ;
|
|
factory_N = LexiconGer.factory_N ;
|
|
faculty_N = DictGer.begabung_N ;
|
|
fag_N = DictGer.schwuchtel_N ;
|
|
faggot_N = DictGer.schwuchtel_N ;
|
|
faience_N = DictGer.steingut_N ;
|
|
fail_V = DictGer.scheitern_V ;
|
|
fail_V2 = P.dirV2 (DictGer.scheitern_V) ;
|
|
faint_A = DictGer.kraftlos_A ;
|
|
fair_A = DictGer.blond_A ;
|
|
faithful_A = DictGer.treu_A ;
|
|
fakir_N = DictGer.fakir_N ;
|
|
falcon_N = DictGer.falke_N ;
|
|
fall_V = LexiconGer.fall_V ;
|
|
fall_V2 = P.dirV2 (DictGer.fallen_6_V) ;
|
|
fallacy_N = DictGer.trugschluss_N ;
|
|
fallible_A = DictGer.fehlbar_A ;
|
|
fallout_N = DictGer.fallout_N ;
|
|
false_A = DictGer.falsch_A ;
|
|
falsehood_N = DictGer.luege_N ;
|
|
falsetto_N = DictGer.falsett_N ;
|
|
falsification_N = DictGer.faelschung_N ;
|
|
family_N = DictGer.familie_N ;
|
|
famine_N = DictGer.hungersnot_N ;
|
|
famous_A = DictGer.bekannt_A ;
|
|
fan_N = DictGer.fan_N ;
|
|
fanatic_A = DictGer.fanatisch_A ;
|
|
fanatical_A = DictGer.fanatisch_A ;
|
|
fantastic_A = DictGer.fantastisch_A ;
|
|
fantasy_N = DictGer.fantasie_N ;
|
|
far_A = DictGer.entfernt_A ;
|
|
farce_N = DictGer.farce_N ;
|
|
fare_N = DictGer.fahrgast_N ;
|
|
farewell_N = DictGer.abschied_N ;
|
|
farm_N = DictGer.bauernhof_N ;
|
|
farmer_N = DictGer.bauer_N ;
|
|
farmhand_N = DictGer.knecht_N ;
|
|
farmhouse_N = DictGer.bauernhaus_N ;
|
|
fart_V = DictGer.furzen_V ;
|
|
fascinate_V2 = P.dirV2 (DictGer.faszinieren_V) ;
|
|
fascination_N = DictGer.faszination_N ;
|
|
fascist_A = DictGer.faschistisch_A ;
|
|
fashion_N = DictGer.mode_N ;
|
|
fast_V = DictGer.fasten_V ;
|
|
fastener_N = DictGer.verschluss_N ;
|
|
fastidious_A = DictGer.anspruchsvoll_A ;
|
|
fat_N = LexiconGer.fat_N ;
|
|
fatal_A = DictGer.fatal_A ;
|
|
fate_N = DictGer.geschick__N ;
|
|
fateful_A = DictGer.vorbestimmt_A ;
|
|
father_N = DictGer.vater_N ;
|
|
fatherhood_N = DictGer.vaterschaft_N ;
|
|
fatigue_N = DictGer.erschoepfung_N ;
|
|
fatten_V = DictGer.maesten_V ;
|
|
fatten_V2 = P.dirV2 (DictGer.maesten_V) ;
|
|
fatty_A = DictGer.fettig_A ;
|
|
fatuous_A = DictGer.toericht_A ;
|
|
fault_N = DictGer.fehler_N ;
|
|
faulty_A = DictGer.fehlerhaft_A ;
|
|
favour_N = DictGer.gefallen_N ;
|
|
fear_N = DictGer.angst_N ;
|
|
fear_V2 = LexiconGer.fear_V2 ;
|
|
fearful_A = DictGer.furchtbar_A ;
|
|
fearless_A = DictGer.furchtlos_A ;
|
|
feasible_A = DictGer.machbar_A ;
|
|
feast_N = DictGer.festmahl_N ;
|
|
feather_N = LexiconGer.feather_N ;
|
|
feature_N = DictGer.besonderheit_N ;
|
|
fecundity_N = DictGer.fertility_N ;
|
|
federation_N = DictGer.bund_N ;
|
|
fee_N = DictGer.gebuehr_N ;
|
|
feed_V = DictGer.fressen_V ;
|
|
feed_V2 = P.dirV2 (DictGer.fressen_V) ;
|
|
feedback_N = DictGer.rueckmeldung_N ;
|
|
feel_V = DictGer.denken_0_V ;
|
|
feel_V2 = P.dirV2 (DictGer.denken_0_V) ;
|
|
feeler_N = DictGer.fuehler_N ;
|
|
feign_V2 = P.dirV2 (DictGer.fingieren_V) ;
|
|
feldspar_N = DictGer.feldspat_N ;
|
|
fell_V2 = P.dirV2 (DictGer.faellen_V) ;
|
|
fellow_N = DictGer.gefaehrte_N ;
|
|
felon_N = DictGer.verbrecher_N ;
|
|
felt_N = DictGer.filz_N ;
|
|
female_A = DictGer.weiblich_A ;
|
|
feminine_A = DictGer.feminin_A ;
|
|
femininity_N = DictGer.weiblichkeit_N ;
|
|
feminism_N = DictGer.feminismus_N ;
|
|
femur_N = DictGer.oberschenkelknochen_N ;
|
|
fence_N = DictGer.hag_N ;
|
|
fencer_N = DictGer.fechter_N ;
|
|
fender_N = DictGer.kotfluegel_N ;
|
|
fennel_N = DictGer.fenchel_N ;
|
|
feral_A = DictGer.wild_A ;
|
|
ferment_V = DictGer.gaeren_V ;
|
|
ferment_V2 = P.dirV2 (DictGer.gaeren_V) ;
|
|
fermentation_N = DictGer.gaerung_N ;
|
|
fern_N = DictGer.farn_N ;
|
|
ferret_N = DictGer.frettchen_N ;
|
|
ferry_N = DictGer.faehre_N ;
|
|
ferryboat_N = DictGer.faehre_N ;
|
|
ferryman_N = DictGer.ferge_N ;
|
|
fertile_A = DictGer.fruchtbar_A ;
|
|
fertility_N = DictGer.fertility_N ;
|
|
fertilization_N = DictGer.befruchtung_N ;
|
|
fertilize_V2 = P.dirV2 (DictGer.befruchten_V) ;
|
|
fester_V = DictGer.eitern_V ;
|
|
festive_A = DictGer.festlich_A ;
|
|
festoon_N = DictGer.feston_N ;
|
|
fetal_A = DictGer.foetal_A ;
|
|
fetch_V = DictGer.holen_4_V ;
|
|
fetch_V2 = P.dirV2 (DictGer.holen_4_V) ;
|
|
feud_N = DictGer.fehde_N ;
|
|
feudal_A = DictGer.feudal_A ;
|
|
fever_N = DictGer.fieber_N ;
|
|
feverish_A = DictGer.fieberhaft_A ;
|
|
fez_N = DictGer.fes_N ;
|
|
fiasco_N = DictGer.fiasko_N ;
|
|
fibre_N = DictGer.faser_N ;
|
|
fibula_N = DictGer.fibel_N ;
|
|
fickle_A = DictGer.unbestaendig_A ;
|
|
fiction_N = DictGer.fiktion_N ;
|
|
fictional_A = DictGer.fiktiv_A ;
|
|
fiddle_N = DictGer.geige_N ;
|
|
fidget_V = DictGer.zappeln_V ;
|
|
fidget_V2 = P.dirV2 (DictGer.zappeln_V) ;
|
|
field_N = DictGer.bereich_N ;
|
|
fiendish_A = DictGer.teuflisch_A ;
|
|
fierce_A = DictGer.wild_A ;
|
|
fig_N = DictGer.feige_N ;
|
|
fight_V = DictGer.bekaempfen_V ;
|
|
fight_V2 = LexiconGer.fight_V2 ;
|
|
fighter_N = DictGer.jaeger_N ;
|
|
figment_N = DictGer.erfindung_N ;
|
|
figurative_A = DictGer.bildlich_A ;
|
|
figure_N = DictGer.abbildung_N ;
|
|
file_N = DictGer.akte_N ;
|
|
fill_V = DictGer.fuellen_9_V ;
|
|
fill_V2 = P.dirV2 (DictGer.fuellen_9_V) ;
|
|
film_N = DictGer.film_N ;
|
|
filter_N = DictGer.filter_N ;
|
|
filthy_A = DictGer.dreckig_A ;
|
|
filtrate_N = DictGer.filtrat_N ;
|
|
fin_N = DictGer.flosse_N ;
|
|
final_N = DictGer.abschlusspruefung_N ;
|
|
finance_N = DictGer.finanz_N ;
|
|
financial_A = DictGer.finanziell_A ;
|
|
financier_N = DictGer.finanzier_N ;
|
|
finch_N = DictGer.fink_N ;
|
|
find_V = DictGer.finden_8_V ;
|
|
find_V2 = LexiconGer.find_V2 ;
|
|
fine_A = DictGer.filigran_A ;
|
|
finger_N = DictGer.finger_N ;
|
|
fingernail_N = LexiconGer.fingernail_N ;
|
|
fingerprint_N = DictGer.fingerabdruck_N ;
|
|
fingertip_N = DictGer.fingerspitze_N ;
|
|
finish_N = DictGer.ende_N ;
|
|
finite_A = DictGer.endlich_A ;
|
|
finnish_A = DictGer.finnisch_A ;
|
|
fir_N = DictGer.tanne_N ;
|
|
fire_N = LexiconGer.fire_N ;
|
|
firearm_N = DictGer.feuerwaffe_N ;
|
|
firebug_N = DictGer.feuerteufel_N ;
|
|
firecracker_N = DictGer.feuerwerkskoerper_N ;
|
|
firefly_N = DictGer.gluehwuermchen_N ;
|
|
fireman_N = DictGer.heizer_N ;
|
|
fireplace_N = DictGer.kamin_N ;
|
|
firework_N = DictGer.feuerwerk_N ;
|
|
firm_N = DictGer.firma_N ;
|
|
fish_N = LexiconGer.fish_N ;
|
|
fishbone_N = DictGer.graete_N ;
|
|
fisher_N = DictGer.fischer_N ;
|
|
fisherman_N = DictGer.fischer_N ;
|
|
fishmonger_N = DictGer.fischhaendler_N ;
|
|
fissile_A = DictGer.spaltbar_A ;
|
|
fission_N = DictGer.kernspaltung_N ;
|
|
fissionable_A = DictGer.spaltbar_A ;
|
|
fissure_N = DictGer.riss_N ;
|
|
fist_N = DictGer.faust_N ;
|
|
fistula_N = DictGer.fistel_N ;
|
|
fit_V = DictGer.passen_7_V ;
|
|
fit_V2 = P.dirV2 (DictGer.passen_7_V) ;
|
|
fizzy_A = DictGer.kohlensaeurehaltig_A ;
|
|
fjord_N = DictGer.fjord_N ;
|
|
flabbergast_V2 = P.dirV2 (DictGer.erstaunen_V) ;
|
|
flaccidity_N = DictGer.atonie_N ;
|
|
flag_N = DictGer.fahne_N ;
|
|
flagpole_N = DictGer.fahnenmast_N ;
|
|
flagship_N = DictGer.flaggschiff_N ;
|
|
flagstaff_N = DictGer.fahnenmast_N ;
|
|
flail_N = DictGer.flegel_N ;
|
|
flair_N = DictGer.begabung_N ;
|
|
flake_N = DictGer.flocke_N ;
|
|
flamboyant_A = DictGer.extravagant_A ;
|
|
flame_N = DictGer.flamme_N ;
|
|
flamethrower_N = DictGer.flammenwerfer_N ;
|
|
flamingo_N = DictGer.flamingo_N ;
|
|
flammable_A = DictGer.brennbar_A ;
|
|
flange_N = DictGer.flansch_N ;
|
|
flannel_N = DictGer.flanell_N ;
|
|
flap_N = DictGer.aufregung_N ;
|
|
flare_N = DictGer.fackel_N ;
|
|
flashback_N = DictGer.flashback_N ;
|
|
flashlight_N = DictGer.taschenlampe_N ;
|
|
flat_A = DictGer.direkt_A ;
|
|
flatfish_N = DictGer.plattfisch_N ;
|
|
flattery_N = DictGer.schmeichelei_N ;
|
|
flatulence_N = DictGer.flatulenz_N ;
|
|
flautist_N = DictGer.floetist_N ;
|
|
flaw_N = DictGer.fehler_N ;
|
|
flax_N = DictGer.lein_N ;
|
|
flay_V2 = P.dirV2 (DictGer.haeuten_1_V) ;
|
|
flea_N = DictGer.floh_N ;
|
|
fleck_N = DictGer.fleck_N ;
|
|
flee_V = DictGer.fliehen_V ;
|
|
flee_V2 = P.dirV2 (DictGer.fliehen_V) ;
|
|
fleet_N = DictGer.flotte_N ;
|
|
flesh_N = DictGer.haut_N ;
|
|
fleshy_A = DictGer.fleischig_A ;
|
|
flexible_A = DictGer.flexibel_A ;
|
|
flick_N = DictGer.kino_N ;
|
|
flight_N = DictGer.flucht_N ;
|
|
fling_N = DictGer.affaere_N ;
|
|
flippant_A = DictGer.frech_A ;
|
|
flipper_N = DictGer.flosse_N ;
|
|
flirtatious_A = DictGer.kokett_A ;
|
|
float_V = LexiconGer.float_V ;
|
|
flock_N = DictGer.herde_N ;
|
|
flood_N = DictGer.flut_N ;
|
|
floor_N = LexiconGer.floor_N ;
|
|
floozie_N = DictGer.flittchen_N ;
|
|
flop_V = DictGer.plumpsen_V ;
|
|
flop_V2 = P.dirV2 (DictGer.plumpsen_V) ;
|
|
floppy_A = DictGer.schlaff_A ;
|
|
florist_N = DictGer.florist_N ;
|
|
floss_N = DictGer.zuckerwatte_N ;
|
|
flounder_N = DictGer.flunder_N ;
|
|
flour_N = DictGer.mehl_N ;
|
|
flourish_V = DictGer.bluehen_9_V ;
|
|
flourish_V2 = P.dirV2 (DictGer.bluehen_9_V) ;
|
|
flout_V2 = P.dirV2 (DictGer.beleidigen_V) ;
|
|
flow_N = DictGer.fluss_N ;
|
|
flow_V = LexiconGer.flow_V ;
|
|
flower_N = LexiconGer.flower_N ;
|
|
flowerbed_N = DictGer.blumenbeet_N ;
|
|
flowerpot_N = DictGer.blumentopf_N ;
|
|
flowery_A = DictGer.blumig_A ;
|
|
flu_N = DictGer.grippe_N ;
|
|
fluctuate_V = DictGer.fluktuieren_V ;
|
|
fluctuation_N = DictGer.fluktuation_N ;
|
|
fluent_A = DictGer.fliessend_A ;
|
|
fluff_N = DictGer.fluse_N ;
|
|
fluffy_A = DictGer.flauschig_A ;
|
|
fluid_N = DictGer.fluid_N ;
|
|
fluorine_N = DictGer.fluor_N ;
|
|
flush_A = DictGer.buendig_A ;
|
|
flute_N = DictGer.floete_N ;
|
|
flutist_N = DictGer.floetist_N ;
|
|
flutter_V = DictGer.flattern_V ;
|
|
flutter_V2 = P.dirV2 (DictGer.flattern_V) ;
|
|
flux_N = DictGer.fluss_N ;
|
|
fly_N = DictGer.fliege_N ;
|
|
fly_V = LexiconGer.fly_V ;
|
|
flyer_N = DictGer.flieger_N ;
|
|
foal_N = DictGer.fohlen_N ;
|
|
foam_N = DictGer.schaum_N ;
|
|
focus_N = DictGer.brennpunkt_N ;
|
|
fog_N = LexiconGer.fog_N ;
|
|
foggy_A = DictGer.diesig_A ;
|
|
foghorn_N = DictGer.nebelhorn_N ;
|
|
foil_N = DictGer.aluminiumfolie_N ;
|
|
fold_N = DictGer.falte_N ;
|
|
folder_N = DictGer.ordner_N ;
|
|
folksy_A = DictGer.gesellig_A ;
|
|
folktale_N = DictGer.maerchen_N ;
|
|
follow_V = DictGer.folgen_V ;
|
|
follow_V2 = P.dirV2 (DictGer.folgen_V) ;
|
|
following_A = DictGer.anschliessend_A ;
|
|
folly_N = DictGer.torheit_N ;
|
|
fondle_V2 = P.dirV2 (DictGer.liebkosen_V) ;
|
|
food_N = DictGer.essen_N ;
|
|
foodstuff_N = DictGer.nahrungsmittel_N ;
|
|
fool_N = DictGer.dummkopf_N ;
|
|
foolish_A = DictGer.dumm_A ;
|
|
foolishness_N = DictGer.dummheit_N ;
|
|
foot_N = LexiconGer.foot_N ;
|
|
footage_N = DictGer.filmmaterial_N ;
|
|
footballer_N = DictGer.fussballer_N ;
|
|
footnote_N = DictGer.fussnote_N ;
|
|
footprint_N = DictGer.fussabdruck_N ;
|
|
footstool_N = DictGer.fussbank_N ;
|
|
forbid_V2 = P.dirV2 (DictGer.untersagen_V) ;
|
|
force_N = DictGer.gewalt_N ;
|
|
ford_N = DictGer.furt_N ;
|
|
forearm_N = DictGer.unterarm_N ;
|
|
forecast_V = DictGer.prognostizieren_V ;
|
|
forecast_V2 = P.dirV2 (DictGer.prognostizieren_V) ;
|
|
forefather_N = DictGer.vorfahre__N ;
|
|
forefinger_N = DictGer.zeigefinger_N ;
|
|
forefront_N = DictGer.vordergrund_N ;
|
|
foreground_N = DictGer.vordergrund_N ;
|
|
forehead_N = DictGer.stirn_N ;
|
|
foreign_A = DictGer.auslaendisch_A ;
|
|
foreigner_N = DictGer.auslaender_N ;
|
|
forename_N = DictGer.vorname_N ;
|
|
forenoon_N = DictGer.vormittag_N ;
|
|
forensic_A = DictGer.forensisch_A ;
|
|
foreseeable_A = DictGer.vorhersehbar_A ;
|
|
foreshore_N = DictGer.wattenmeer_N ;
|
|
foresight_N = DictGer.voraussicht_N ;
|
|
foreskin_N = DictGer.vorhaut_N ;
|
|
forest_N = LexiconGer.forest_N ;
|
|
foreword_N = DictGer.vorwort_N ;
|
|
forge_N = DictGer.schmiede_N ;
|
|
forgery_N = DictGer.falsifikat_N ;
|
|
forget_V = DictGer.vergessen_V ;
|
|
forget_V2 = LexiconGer.forget_V2 ;
|
|
forgetful_A = DictGer.vergesslich_A ;
|
|
forgiveness_N = DictGer.vergebung_N ;
|
|
fork_N = DictGer.gabel_N ;
|
|
form_N = DictGer.form_N ;
|
|
formal_A = DictGer.formal_A ;
|
|
format_N = DictGer.format_N ;
|
|
formula_N = DictGer.formel_N ;
|
|
forsythia_N = DictGer.forsythie_N ;
|
|
fort_N = DictGer.festung_N ;
|
|
forthcoming_A = DictGer.entgegenkommend_A ;
|
|
fortification_N = DictGer.festung_N ;
|
|
fortress_N = DictGer.festung_N ;
|
|
fortune_N = DictGer.schicksal_N ;
|
|
fossil_N = DictGer.fossil_N ;
|
|
foul_A = DictGer.faul_A ;
|
|
foundation_N = DictGer.fundament_N ;
|
|
founder_N = DictGer.gruender_N ;
|
|
foundling_N = DictGer.findelkind_N ;
|
|
foundry_N = DictGer.giesserei_N ;
|
|
fount_N = DictGer.quelle_N ;
|
|
fountain_N = DictGer.springbrunnen_N ;
|
|
fowl_N = DictGer.gefluegel_N ;
|
|
fox_N = DictGer.fuchs_N ;
|
|
foxglove_N = DictGer.fingerhut_N ;
|
|
foyer_N = DictGer.foyer_N ;
|
|
fracas_N = DictGer.aufruhr_N ;
|
|
fraction_N = DictGer.bruch_N ;
|
|
fractious_A = DictGer.aufsaessig_A ;
|
|
fracture_N = DictGer.bruch_N ;
|
|
fragile_A = DictGer.fragil_A ;
|
|
fragment_N = DictGer.fragment_N ;
|
|
fragmentary_A = DictGer.fragmentarisch_A ;
|
|
fragmentation_N = DictGer.fragmentierung_N ;
|
|
frame_V = DictGer.entwerfen_V ;
|
|
frame_V2 = P.dirV2 (DictGer.entwerfen_V) ;
|
|
framework_N = DictGer.fachwerk_N ;
|
|
franc_N = DictGer.franc_N ;
|
|
franchise_N = DictGer.konzession_N ;
|
|
frankincense_N = DictGer.weihrauch_N ;
|
|
fraud_N = DictGer.betrug_N ;
|
|
fray_N = DictGer.schlacht_N ;
|
|
freak_N = DictGer.freak_N ;
|
|
freckle_N = DictGer.sommersprosse_N ;
|
|
free_A = DictGer.gratis_A ;
|
|
freedom_N = DictGer.freiheit_N ;
|
|
freemason_N = DictGer.freimaurer_N ;
|
|
freeway_N = DictGer.autobahn_N ;
|
|
freeze_V = LexiconGer.freeze_V ;
|
|
freezer_N = DictGer.gefrierschrank_N ;
|
|
freight_N = DictGer.fracht_N ;
|
|
frenzy_N = DictGer.rausch_N ;
|
|
frequency_N = DictGer.frequenz_N ;
|
|
frequent_A = DictGer.haeufig_A ;
|
|
fresco_N = DictGer.fresko_N ;
|
|
fresh_A = DictGer.frech_A ;
|
|
freshman_N = DictGer.neuling_N ;
|
|
fret_V = DictGer.verschlingen_V ;
|
|
fret_V2 = P.dirV2 (DictGer.verschlingen_V) ;
|
|
fricassee_N = DictGer.frikassee_N ;
|
|
fricative_N = DictGer.frikativ_N ;
|
|
friction_N = DictGer.reibung_N ;
|
|
friday_N = DictGer.freitag_N ;
|
|
fridge_N = LexiconGer.fridge_N ;
|
|
friend_N = LexiconGer.friend_N ;
|
|
friendliness_N = DictGer.freundlichkeit_N ;
|
|
friendly_A = DictGer.freundlich_A ;
|
|
friendship_N = DictGer.freundschaft_N ;
|
|
frieze_N = DictGer.fries_N ;
|
|
frigate_N = DictGer.fregatte_N ;
|
|
fright_N = DictGer.schreck_N ;
|
|
frighten_V2 = P.dirV2 (DictGer.erschrecken_V) ;
|
|
frigid_A = DictGer.kalt_A ;
|
|
frivolous_A = DictGer.frivol_A ;
|
|
frock_N = DictGer.kleid_N ;
|
|
frog_N = DictGer.frosch_N ;
|
|
front_N = DictGer.front_N ;
|
|
frontal_A = DictGer.frontal_A ;
|
|
frontier_N = DictGer.grenze_N ;
|
|
frost_N = DictGer.frost_N ;
|
|
frostbite_N = DictGer.erfrierung_N ;
|
|
frosty_A = DictGer.frostig_A ;
|
|
froth_N = DictGer.schaum_N ;
|
|
fruit_N = LexiconGer.fruit_N ;
|
|
fruiterer_N = DictGer.obsthaendler_N ;
|
|
fruitful_A = DictGer.fruchtbar_A ;
|
|
frustration_N = DictGer.frustration_N ;
|
|
fry_V = DictGer.braten_V ;
|
|
fry_V2 = P.dirV2 (DictGer.braten_V) ;
|
|
fuck_V = DictGer.bumsen_V ;
|
|
fuck_V2 = P.dirV2 (DictGer.bumsen_V) ;
|
|
fuel_N = DictGer.brennstoff_N ;
|
|
fug_N = DictGer.muff_N ;
|
|
fugitive_N = DictGer.fluechtling_N ;
|
|
fugue_N = DictGer.fuge_N ;
|
|
fulfil_V2 = P.dirV2 (DictGer.erfuellen_V) ;
|
|
fulfill_V2 = P.dirV2 (DictGer.erfuellen_V) ;
|
|
full_A = LexiconGer.full_A ;
|
|
fume_N = DictGer.rauch_N ;
|
|
function_N = DictGer.aufgabe_N ;
|
|
functional_A = DictGer.funktional_A ;
|
|
fund_N = DictGer.fonds_N ;
|
|
fundamental_N = DictGer.grundlage_N ;
|
|
fundamentalism_N = DictGer.fundamentalismus_N ;
|
|
fungicide_N = DictGer.fungizid_N ;
|
|
fungus_N = DictGer.pilz_N ;
|
|
funnel_N = DictGer.trichter_N ;
|
|
funny_A = DictGer.eigenartig_A ;
|
|
fur_N = DictGer.fell_N ;
|
|
furbelow_N = DictGer.krause_N ;
|
|
furlough_N = DictGer.urlaub_N ;
|
|
furnace_N = DictGer.hochofen_N ;
|
|
furniture_N = DictGer.moebelstueck_N ;
|
|
furrier_N = DictGer.kuerschner_N ;
|
|
furry_A = DictGer.pelzig_A ;
|
|
further_V2 = P.dirV2 (DictGer.foerdern_V) ;
|
|
furtive_A = DictGer.geheim_A ;
|
|
fuse_N = DictGer.sicherung_N ;
|
|
fuss_N = DictGer.aufstand_N ;
|
|
fusty_A = DictGer.modrig_A ;
|
|
futile_A = DictGer.sinnlos_A ;
|
|
future_N = DictGer.futur_N ;
|
|
fuzzy_A = DictGer.vage_A ;
|
|
gable_N = DictGer.giebel_N ;
|
|
gadfly_N = DictGer.bremse_N ;
|
|
gadget_N = DictGer.apparat_N ;
|
|
gag_N = DictGer.gag_N ;
|
|
gait_N = DictGer.gang_N ;
|
|
galaxy_N = DictGer.galaxie_N ;
|
|
gall_N = DictGer.frechheit_N ;
|
|
galleon_N = DictGer.galeone_N ;
|
|
gallery_N = DictGer.galerie_N ;
|
|
galley_N = DictGer.galeere_N ;
|
|
gallstone_N = DictGer.gallenstein_N ;
|
|
galosh_N = DictGer.galosche_N ;
|
|
gambit_N = DictGer.gambit_N ;
|
|
gamble_N = DictGer.gluecksspiel_N ;
|
|
gambler_N = DictGer.hasardeur_N ;
|
|
game_N = DictGer.spiel_N ;
|
|
gamma_N = DictGer.gamma_N ;
|
|
gander_N = DictGer.blick_N ;
|
|
ganglion_N = DictGer.kopf_N ;
|
|
gangplank_N = DictGer.landungsbruecke_N ;
|
|
gangrene_N = DictGer.gangraen_N ;
|
|
gangster_N = DictGer.gangster_N ;
|
|
gangway_N = DictGer.gang_N ;
|
|
gannet_N = DictGer.basstoelpel_N ;
|
|
gap_N = DictGer.ritz_N ;
|
|
garage_N = DictGer.garage_N ;
|
|
garbage_N = DictGer.abfall_N ;
|
|
garden_N = LexiconGer.garden_N ;
|
|
gardener_N = DictGer.gaertner_N ;
|
|
gargle_V = DictGer.gurgeln_V ;
|
|
gargle_V2 = P.dirV2 (DictGer.gurgeln_V) ;
|
|
garment_N = DictGer.kleidungsstueck_N ;
|
|
garnish_V2 = P.dirV2 (DictGer.garnieren_V) ;
|
|
garrison_N = DictGer.garnison_N ;
|
|
garrulous_A = DictGer.geschwaetzig_A ;
|
|
gas_N = DictGer.benzin_N ;
|
|
gaseous_A = DictGer.gasfoermig_A ;
|
|
gasket_N = DictGer.dichtung_N ;
|
|
gasoline_N = DictGer.benzin_N ;
|
|
gastritis_N = DictGer.gastritis_N ;
|
|
gastronomy_N = DictGer.gastronomie_N ;
|
|
gate_N = DictGer.schlagbaum_N ;
|
|
gateway_N = DictGer.einfahrt_N ;
|
|
gather_V = DictGer.sammeln_V ;
|
|
gather_V2 = P.dirV2 (DictGer.sammeln_V) ;
|
|
gaudy_A = DictGer.grell_A ;
|
|
gaunt_A = DictGer.duenn_A ;
|
|
gauze_N = DictGer.gaze_N ;
|
|
gay_A = DictGer.ausgelassen_A ;
|
|
gazelle_N = DictGer.gazelle_N ;
|
|
gear_N = DictGer.gang_N ;
|
|
geisha_N = DictGer.geisha_N ;
|
|
gel_N = DictGer.gel_N ;
|
|
gelatine_N = DictGer.gelatine_N ;
|
|
gelding_N = DictGer.wallach_N ;
|
|
gem_N = DictGer.edelstein_N ;
|
|
gendarme_N = DictGer.gendarm_N ;
|
|
gender_N = DictGer.geschlecht_N ;
|
|
gene_N = DictGer.gen_N ;
|
|
genealogy_N = DictGer.abstammung_N ;
|
|
general_A = DictGer.allgemein_A ;
|
|
generator_N = DictGer.generator_N ;
|
|
generic_A = DictGer.allgemein_A ;
|
|
generosity_N = DictGer.generositaet_N ;
|
|
generous_A = DictGer.generoes_A ;
|
|
genetic_A = DictGer.genetisch_A ;
|
|
genius_N = DictGer.genie_N ;
|
|
genocide_N = DictGer.voelkermord_N ;
|
|
genre_N = DictGer.genre_N ;
|
|
gentleman_N = DictGer.herr_N ;
|
|
genuine_A = DictGer.echt_A ;
|
|
genus_N = DictGer.gattung_N ;
|
|
geography_N = DictGer.geografie_N ;
|
|
geologist_N = DictGer.geologe_N ;
|
|
geometric_A = DictGer.geometrisch_A ;
|
|
geometry_N = DictGer.geometrie_N ;
|
|
geranium_N = DictGer.geranie_N ;
|
|
germ_N = DictGer.keim_N ;
|
|
german_N = DictGer.germane_N ;
|
|
germane_A = DictGer.relevant_A ;
|
|
gerund_N = DictGer.gerundium_N ;
|
|
gesture_N = DictGer.attituede_N ;
|
|
get_V = DictGer.werden_V ;
|
|
get_V2 = P.dirV2 (DictGer.werden_V) ;
|
|
geyser_N = DictGer.geysir_N ;
|
|
gherkin_N = DictGer.gewuerzgurke_N ;
|
|
ghost_N = DictGer.erscheinung_N ;
|
|
giant_N = DictGer.gigant_N ;
|
|
gibbon_N = DictGer.gibbon_N ;
|
|
gift_N = DictGer.begabung_N ;
|
|
gig_N = DictGer.auftritt_N ;
|
|
gigantic_A = DictGer.gigantisch_A ;
|
|
giggle_V = DictGer.kichern_V ;
|
|
gild_V2 = P.dirV2 (DictGer.vergolden_V) ;
|
|
gill_N = DictGer.kieme_N ;
|
|
gin_N = DictGer.gin_N ;
|
|
ginger_N = DictGer.ingwer_N ;
|
|
gingerbread_N = DictGer.lebkuchen_N ;
|
|
giraffe_N = DictGer.giraffe_N ;
|
|
girder_N = DictGer.balken_N ;
|
|
girl_N = LexiconGer.girl_N ;
|
|
girlfriend_N = DictGer.freundin_N ;
|
|
girlish_A = DictGer.maedchenhaft_A ;
|
|
girth_N = DictGer.umfang_N ;
|
|
give_V = DictGer.geben_9_V ;
|
|
give_V2 = P.dirV2 (DictGer.geben_9_V) ;
|
|
give_V3 = LexiconGer.give_V3 ;
|
|
glacier_N = DictGer.gletscher_N ;
|
|
glad_A = DictGer.froh_A ;
|
|
gladiator_N = DictGer.gladiator_N ;
|
|
glance_V = DictGer.blicken_V ;
|
|
glance_V2 = P.dirV2 (DictGer.blicken_V) ;
|
|
gland_N = DictGer.druese_N ;
|
|
glaze_N = DictGer.glasur_N ;
|
|
glee_N = DictGer.freude_N ;
|
|
gleeful_A = DictGer.schadenfroh_A ;
|
|
glide_V = DictGer.gleiten_V ;
|
|
glider_N = DictGer.segelflugzeug_N ;
|
|
glisten_V = DictGer.glitzern_V ;
|
|
global_A = DictGer.global_A ;
|
|
globe_N = DictGer.erde_N ;
|
|
globetrotter_N = DictGer.weltenbummler_N ;
|
|
glockenspiel_N = DictGer.glockenspiel_N ;
|
|
gloomy_A = DictGer.duester_A ;
|
|
glorification_N = DictGer.glorifizierung_N ;
|
|
glorious_A = DictGer.glorreich_A ;
|
|
gloss_N = DictGer.randbemerkung_N ;
|
|
glossy_A = DictGer.glaenzend_A ;
|
|
glottis_N = DictGer.glottis_N ;
|
|
glove_N = LexiconGer.glove_N ;
|
|
glow_V = DictGer.gluehen_V ;
|
|
glue_N = DictGer.kleber_N ;
|
|
gluey_A = DictGer.klebrig_A ;
|
|
glutinous_A = DictGer.klebrig_A ;
|
|
gnaw_V = DictGer.nagen_V ;
|
|
gnaw_V2 = P.dirV2 (DictGer.nagen_V) ;
|
|
gnu_N = DictGer.gnu_N ;
|
|
go_V = LexiconGer.go_V ;
|
|
go_V2 = P.dirV2 (DictGer.fahren_7_V) ;
|
|
goal_N = DictGer.tor_N ;
|
|
goalkeeper_N = DictGer.torhueterin_N ;
|
|
goat_N = DictGer.geiss_N ;
|
|
goatee_N = DictGer.ziegenbart_N ;
|
|
gob_N = DictGer.schnauze_N ;
|
|
goblet_N = DictGer.kelch_N ;
|
|
goblin_N = DictGer.kobold_N ;
|
|
god_N = DictGer.gott_N ;
|
|
godchild_N = DictGer.patenkind_N ;
|
|
goddess_N = DictGer.goettin_N ;
|
|
godfather_N = DictGer.pate_N ;
|
|
godless_A = DictGer.gottlos_A ;
|
|
godly_A = DictGer.fromm_A ;
|
|
godmother_N = DictGer.patin_N ;
|
|
goggle_V = DictGer.glotzen_V ;
|
|
goitre_N = DictGer.kropf_N ;
|
|
gold_N = LexiconGer.gold_N ;
|
|
golden_A = DictGer.golden_A ;
|
|
goldfinch_N = DictGer.stieglitz_N ;
|
|
goldfish_N = DictGer.goldfisch_N ;
|
|
golf_N = DictGer.golf_N ;
|
|
gondola_N = DictGer.gondel_N ;
|
|
goo_N = DictGer.klebstoff_N ;
|
|
good_A = LexiconGer.good_A ;
|
|
goose_N = DictGer.gans_N ;
|
|
gooseberry_N = DictGer.stachelbeere_N ;
|
|
gorge_N = DictGer.schlucht_N ;
|
|
gorilla_N = DictGer.gorilla_N ;
|
|
gormless_A = DictGer.daemlich_A ;
|
|
gory_A = DictGer.blutig_A ;
|
|
gosling_N = DictGer.gruenschnabel_N ;
|
|
gossip_N = DictGer.klatsch_N ;
|
|
gouge_N = DictGer.rille_N ;
|
|
gourd_N = DictGer.kalebasse_N ;
|
|
gourmand_N = DictGer.feinschmecker__N ;
|
|
gout_N = DictGer.gicht_N ;
|
|
govern_V = DictGer.lenken_1_V ;
|
|
govern_V2 = P.dirV2 (DictGer.lenken_1_V) ;
|
|
governess_N = DictGer.gouvernante_N ;
|
|
government_N = DictGer.regierung_N ;
|
|
governor_N = DictGer.gouverneur_N ;
|
|
grab_V = DictGer.greifen_8_V ;
|
|
grab_V2 = P.dirV2 (DictGer.greifen_8_V) ;
|
|
grace_N = DictGer.aufschub_N ;
|
|
graceful_A = DictGer.anmutig_A ;
|
|
gradual_A = DictGer.graduell_A ;
|
|
graduate_N = DictGer.absolvent_N ;
|
|
graduation_N = DictGer.abschluss_N ;
|
|
grain_N = DictGer.getreide_N ;
|
|
gram_N = DictGer.gramm_N ;
|
|
grammar_N = LexiconGer.grammar_N ;
|
|
grammarian_N = DictGer.grammatiker_N ;
|
|
grammatical_A = DictGer.grammatikalisch_A ;
|
|
grandaunt_N = DictGer.grosstante_N ;
|
|
grandchild_N = DictGer.enkelkind_N ;
|
|
granddaughter_N = DictGer.enkelin_N ;
|
|
grandfather_N = DictGer.grossvater_N ;
|
|
grandma_N = DictGer.oma_N ;
|
|
grandmother_N = DictGer.grossmutter_N ;
|
|
grandnephew_N = DictGer.grossneffe_N ;
|
|
grandniece_N = DictGer.grossnichte_N ;
|
|
grandpa_N = DictGer.opa_N ;
|
|
grandson_N = DictGer.enkel_N ;
|
|
granduncle_N = DictGer.grossonkel_N ;
|
|
granite_N = DictGer.granit_N ;
|
|
grape_N = DictGer.weinbeere_N ;
|
|
grapefruit_N = DictGer.grapefruit_N ;
|
|
grapevine_N = DictGer.rebstock_N ;
|
|
graph_N = DictGer.graph_N ;
|
|
graphic_A = DictGer.grafisch_A ;
|
|
graphical_A = DictGer.grafisch_A ;
|
|
grasp_V = DictGer.begreifen_V ;
|
|
grasp_V2 = P.dirV2 (DictGer.begreifen_V) ;
|
|
grass_N = LexiconGer.grass_N ;
|
|
grasshopper_N = DictGer.heuschrecke_N ;
|
|
grateful_A = DictGer.dankbar_A ;
|
|
gratefulness_N = DictGer.dankbarkeit_N ;
|
|
grater_N = DictGer.reibe_N ;
|
|
gratitude_N = DictGer.dankbarkeit_N ;
|
|
gratuitous_A = DictGer.gratis_A ;
|
|
grave_N = DictGer.grab_N ;
|
|
gravel_N = DictGer.kies_N ;
|
|
gravitation_N = DictGer.schwerkraft_N ;
|
|
gravity_N = DictGer.schwerkraft_N ;
|
|
gravy_N = DictGer.sosse_N ;
|
|
graze_N = DictGer.kratzer_N ;
|
|
grease_N = DictGer.fett_N ;
|
|
greasy_A = DictGer.schmierig_A ;
|
|
great_A = DictGer.fein_A ;
|
|
greatness_N = DictGer.groesse_N ;
|
|
greed_N = DictGer.habsucht_N ;
|
|
greek_N = DictGer.grieche_N ;
|
|
green_A = LexiconGer.green_A ;
|
|
greengage_N = DictGer.reneklode_N ;
|
|
greengrocer_N = DictGer.gemuesehaendler_N ;
|
|
greenhorn_N = DictGer.gruenschnabel_N ;
|
|
greenhouse_N = DictGer.gewaechshaus_N ;
|
|
greenish_A = DictGer.gruenlich_A ;
|
|
greet_V2 = P.dirV2 (DictGer.begruessen_V) ;
|
|
greeting_N = DictGer.begruessung_N ;
|
|
gregarious_A = DictGer.gesellig_A ;
|
|
grenade_N = DictGer.granatapfel_N ;
|
|
grey_A = DictGer.grau_A ;
|
|
gridiron_N = DictGer.rost_N ;
|
|
grill_V = DictGer.grillen_1_V ;
|
|
grill_V2 = P.dirV2 (DictGer.grillen_1_V) ;
|
|
grimace_N = DictGer.grimasse_N ;
|
|
grind_V = DictGer.mahlen_V ;
|
|
grind_V2 = P.dirV2 (DictGer.mahlen_V) ;
|
|
grip_V = DictGer.greifen_8_V ;
|
|
grip_V2 = P.dirV2 (DictGer.greifen_8_V) ;
|
|
grisly_A = DictGer.graesslich_A ;
|
|
grit_N = DictGer.ballaststoff_N ;
|
|
gritty_A = DictGer.mutig_A ;
|
|
grocer_N = DictGer.einzelhaendler_N ;
|
|
grocery_N = DictGer.lebensmittelgeschaeft_N ;
|
|
grog_N = DictGer.grog_N ;
|
|
groin_N = DictGer.leiste_N ;
|
|
grope_V = DictGer.tasten_V ;
|
|
grope_V2 = P.dirV2 (DictGer.tasten_V) ;
|
|
gross_A = DictGer.dick_A ;
|
|
grotesque_A = DictGer.grotesk_A ;
|
|
grotto_N = DictGer.grotte_N ;
|
|
ground_N = DictGer.boden_N ;
|
|
groundless_A = DictGer.grundlos_A ;
|
|
groundwork_N = DictGer.grundlage_N ;
|
|
group_N = DictGer.gruppe_N ;
|
|
grove_N = DictGer.hain_N ;
|
|
grow_V = DictGer.wachsen_0_V ;
|
|
grow_V2 = P.dirV2 (DictGer.wachsen_0_V) ;
|
|
grub_N = DictGer.larve_N ;
|
|
gruesome_A = DictGer.grauenhaft_A ;
|
|
grumpy_A = DictGer.muerrisch_A ;
|
|
guarantee_N = DictGer.garant_N ;
|
|
guarantor_N = DictGer.garant_N ;
|
|
guard_N = DictGer.schutz_N ;
|
|
guardian_N = DictGer.wache_N ;
|
|
guava_N = DictGer.guave_N ;
|
|
guess_N = DictGer.vermutung_N ;
|
|
guest_N = DictGer.gast_N ;
|
|
guesthouse_N = DictGer.gasthaus_N ;
|
|
guideline_N = DictGer.richtlinie_N ;
|
|
guild_N = DictGer.gilde_N ;
|
|
guileless_A = DictGer.arglos_A ;
|
|
guillotine_N = DictGer.guillotine_N ;
|
|
guilt_N = DictGer.schuld_N ;
|
|
guilty_A = DictGer.fehlbar_A ;
|
|
guise_N = DictGer.erscheinung_N ;
|
|
guitar_N = DictGer.gitarre_N ;
|
|
guitarist_N = DictGer.gitarrenspieler_N ;
|
|
gulf_N = DictGer.golf_N ;
|
|
gull_N = DictGer.moewe_N ;
|
|
gullet_N = DictGer.speiseroehre_N ;
|
|
gullible_A = DictGer.einfaeltig_A ;
|
|
gum_N = DictGer.kautschuk_N ;
|
|
gun_N = DictGer.gewehr_N ;
|
|
gunpowder_N = DictGer.schiesspulver_N ;
|
|
gunsmith_N = DictGer.waffenschmied_N ;
|
|
gurgle_V = DictGer.gurgeln_V ;
|
|
guru_N = DictGer.guru_N ;
|
|
gush_N = DictGer.schwall_N ;
|
|
gut_N = DictGer.bauch_N ;
|
|
gutter_N = DictGer.dachrinne_N ;
|
|
guy_N = DictGer.kerl_N ;
|
|
guzzle_V = DictGer.saufen_V ;
|
|
guzzle_V2 = P.dirV2 (DictGer.saufen_V) ;
|
|
gym_N = DictGer.fitnessstudio_N ;
|
|
gymnasium_N = DictGer.fitnessstudio_N ;
|
|
gymnast_N = DictGer.turner_N ;
|
|
gynaecologist_N = DictGer.frauenarzt_N ;
|
|
gynecological_A = DictGer.gynaekologisch_A ;
|
|
gypsum_N = DictGer.gips_N ;
|
|
gypsy_N = DictGer.zigeuner_N ;
|
|
gyro_N = DictGer.gyros_N ;
|
|
habit_N = DictGer.gewohnheit_N ;
|
|
habitable_A = DictGer.bewohnbar_A ;
|
|
habitat_N = DictGer.habitat_N ;
|
|
habitual_A = DictGer.gewoehnlich_A ;
|
|
hackneyed_A = DictGer.banal_A ;
|
|
haddock_N = DictGer.schellfisch_N ;
|
|
haemorrhage_N = DictGer.blutung_N ;
|
|
haggard_A = DictGer.wild_A ;
|
|
haggle_V = DictGer.feilschen_V ;
|
|
hailstone_N = DictGer.hagelkorn_N ;
|
|
hair_N = LexiconGer.hair_N ;
|
|
haircut_N = DictGer.frisur_N ;
|
|
hairdresser_N = DictGer.friseur_N ;
|
|
hairnet_N = DictGer.haarnetz_N ;
|
|
hairstyle_N = DictGer.frisur_N ;
|
|
hairy_A = DictGer.behaart_A ;
|
|
hake_N = DictGer.seehecht_N ;
|
|
halberd_N = DictGer.hellebarde_N ;
|
|
halibut_N = DictGer.heilbutt_N ;
|
|
halitosis_N = DictGer.mundgeruch_N ;
|
|
hall_N = DictGer.flur_N ;
|
|
hallelujah_N = DictGer.halleluja_N ;
|
|
hallucination_N = DictGer.halluzination_N ;
|
|
halo_N = DictGer.heiligenschein_N ;
|
|
halt_V = DictGer.rasten_3_V ;
|
|
halt_V2 = P.dirV2 (DictGer.rasten_3_V) ;
|
|
halve_V2 = P.dirV2 (DictGer.halbieren_V) ;
|
|
ham_N = DictGer.schinken_N ;
|
|
hamburger_N = DictGer.hamburger_N ;
|
|
hamlet_N = DictGer.weiler_N ;
|
|
hammer_N = DictGer.hammer_N ;
|
|
hammock_N = DictGer.haengematte_N ;
|
|
hamper_N = DictGer.hindernis_N ;
|
|
hamster_N = DictGer.hamster_N ;
|
|
hand_N = LexiconGer.hand_N ;
|
|
handbag_N = DictGer.handtasche_N ;
|
|
handbook_N = DictGer.handbuch_N ;
|
|
handcuff_N = DictGer.handschelle_N ;
|
|
handicap_N = DictGer.behinderung_N ;
|
|
handicraft_N = DictGer.handarbeit_N ;
|
|
handkerchief_N = DictGer.halstuch_N ;
|
|
handle_N = DictGer.griff_N ;
|
|
handshake_N = DictGer.handschlag_N ;
|
|
handsome_A = DictGer.huebsch_A ;
|
|
handstand_N = DictGer.handstand_N ;
|
|
handwriting_N = DictGer.handschrift_N ;
|
|
hang_V = DictGer.haengen_4_V ;
|
|
hang_V2 = P.dirV2 (DictGer.haengen_4_V) ;
|
|
hangar_N = DictGer.hangar_N ;
|
|
hangnail_N = DictGer.niednagel_N ;
|
|
hangover_N = DictGer.kater_N ;
|
|
haphazard_A = DictGer.willkuerlich_A ;
|
|
hapless_A = DictGer.unglueckselig_A ;
|
|
happen_V = DictGer.geschehen_V ;
|
|
happen_V2 = P.dirV2 (DictGer.geschehen_V) ;
|
|
happy_A = DictGer.gluecklich_A ;
|
|
harangue_N = DictGer.tirade_N ;
|
|
harass_V2 = P.dirV2 (DictGer.belaestigen_V) ;
|
|
harassment_N = DictGer.belaestigung_N ;
|
|
harbour_N = LexiconGer.harbour_N ;
|
|
hard_A = DictGer.fix_A ;
|
|
hardness_N = DictGer.haerte_N ;
|
|
hardship_N = DictGer.haerte_N ;
|
|
hardworking_A = DictGer.eifrig_A ;
|
|
hare_N = DictGer.hase_N ;
|
|
harelip_N = DictGer.hasenscharte_N ;
|
|
harem_N = DictGer.harem_N ;
|
|
harlot_N = DictGer.dirne_N ;
|
|
harm_N = DictGer.schaden_N ;
|
|
harmful_A = DictGer.schaedlich_A ;
|
|
harmless_A = DictGer.harmlos_A ;
|
|
harmonica_N = DictGer.glasharmonika_N ;
|
|
harmonium_N = DictGer.harmonium_N ;
|
|
harmony_N = DictGer.harmonie_N ;
|
|
harness_N = DictGer.geschirr_N ;
|
|
harp_N = DictGer.harfe_N ;
|
|
harpoon_N = DictGer.harpune_N ;
|
|
harpsichord_N = DictGer.spinett_N ;
|
|
harridan_N = DictGer.drache_N ;
|
|
harrier_N = DictGer.weihe_N ;
|
|
harrow_N = DictGer.egge_N ;
|
|
harsh_A = DictGer.grell_A ;
|
|
harvest_N = DictGer.ernte_N ;
|
|
hash_N = DictGer.doppelkreuz_N ;
|
|
hassle_N = DictGer.muehe_N ;
|
|
hasty_A = DictGer.hastig_A ;
|
|
hat_N = LexiconGer.hat_N ;
|
|
hatch_N = DictGer.luke_N ;
|
|
hatchet_N = DictGer.beil_N ;
|
|
hate_V2 = LexiconGer.hate_V2 ;
|
|
hateful_A = DictGer.hasserfuellt_A ;
|
|
hatter_N = DictGer.hutmacher_N ;
|
|
haughty_A = DictGer.stolz_A ;
|
|
have_V = DictGer.bekommen_8_V ;
|
|
haven_N = DictGer.hafen_N ;
|
|
havoc_N = DictGer.zerstoerung_N ;
|
|
hawk_N = DictGer.habicht_N ;
|
|
hawser_N = DictGer.trosse_N ;
|
|
hawthorn_N = DictGer.weissdorn_N ;
|
|
hay_N = DictGer.hay_N ;
|
|
haystack_N = DictGer.heuschober_N ;
|
|
hazard_N = DictGer.gefahr_N ;
|
|
hazardous_A = DictGer.gefaehrlich_A ;
|
|
haze_N = DictGer.dunst_N ;
|
|
hazel_N = DictGer.haselnuss_N ;
|
|
hazy_A = DictGer.trueb_A ;
|
|
head_N = LexiconGer.head_N ;
|
|
headdress_N = DictGer.kopfbedeckung_N ;
|
|
header_N = DictGer.kopfball_N ;
|
|
headgear_N = DictGer.kopfbedeckung_N ;
|
|
headlamp_N = DictGer.scheinwerfer_N ;
|
|
headlight_N = DictGer.scheinwerfer_N ;
|
|
headstone_N = DictGer.grabstein_N ;
|
|
healthy_A = DictGer.anstaendig_A ;
|
|
heap_N = DictGer.haufen_N ;
|
|
hear_V = DictGer.hoeren_7_V ;
|
|
hear_V2 = LexiconGer.hear_V2 ;
|
|
hearse_N = DictGer.leichenwagen_N ;
|
|
heart_N = LexiconGer.heart_N ;
|
|
heartburn_N = DictGer.sodbrennen_N ;
|
|
heartfelt_A = DictGer.herzlich_A ;
|
|
hearth_N = DictGer.herd_N ;
|
|
hearty_A = DictGer.herzlich_A ;
|
|
heat_N = DictGer.brunft_N ;
|
|
heath_N = DictGer.heide_N ;
|
|
heather_N = DictGer.erika_N ;
|
|
heating_N = DictGer.heizung_N ;
|
|
heatwave_N = DictGer.hitzewelle_N ;
|
|
heaven_N = DictGer.himmel__N ;
|
|
heavy_A = LexiconGer.heavy_A ;
|
|
hectare_N = DictGer.hektar_N ;
|
|
hectic_A = DictGer.hektisch_A ;
|
|
hedge_N = DictGer.hecke_N ;
|
|
hedgehog_N = DictGer.igel_N ;
|
|
hedonism_N = DictGer.hedonismus_N ;
|
|
hedonist_N = DictGer.hedonist_N ;
|
|
hedonistic_A = DictGer.hedonistisch_A ;
|
|
heel_N = DictGer.absatz_N ;
|
|
hegemony_N = DictGer.hegemonie_N ;
|
|
heifer_N = DictGer.faerse_N ;
|
|
height_N = DictGer.groesse_N ;
|
|
heirloom_N = DictGer.erbstueck_N ;
|
|
helicopter_N = DictGer.helikopter__N ;
|
|
helm_N = DictGer.ruder_N ;
|
|
helmet_N = DictGer.helm_N ;
|
|
help_N = DictGer.hilfe_N ;
|
|
helpful_A = DictGer.hilfreich_A ;
|
|
hem_N = DictGer.saum_N ;
|
|
hemisphere_N = DictGer.halbkugel_N ;
|
|
hemlock_N = DictGer.schierling_N ;
|
|
henbane_N = DictGer.bilsenkraut_N ;
|
|
henhouse_N = DictGer.huehnerstall_N ;
|
|
hepatitis_N = DictGer.hepatitis_N ;
|
|
herb_N = DictGer.kraut_N ;
|
|
herd_N = DictGer.herde_N ;
|
|
herdsman_N = DictGer.schaefer_N ;
|
|
hereditary_A = DictGer.erblich_A ;
|
|
heresy_N = DictGer.haeresie_N ;
|
|
heretic_N = DictGer.haeretiker_N ;
|
|
heretical_A = DictGer.ketzerisch_A ;
|
|
heritage_N = DictGer.erbschaft_N ;
|
|
hermaphrodite_N = DictGer.hermaphrodit_N ;
|
|
hermetic_A = DictGer.hermetisch_A ;
|
|
hermit_N = DictGer.eremit_N ;
|
|
hernia_N = DictGer.bruch_N ;
|
|
hero_N = DictGer.held_N ;
|
|
heroic_A = DictGer.heldenhaft_A ;
|
|
heroine_N = DictGer.heldin_N ;
|
|
heron_N = DictGer.reiher_N ;
|
|
herring_N = DictGer.hering_N ;
|
|
hesitant_A = DictGer.zoegerlich_A ;
|
|
hesitate_V = DictGer.stammeln_V ;
|
|
heterogeneous_A = DictGer.heterogen_A ;
|
|
heterosexual_A = DictGer.heterosexuell_A ;
|
|
heterosexuality_N = DictGer.heterosexualitaet_N ;
|
|
heuristic_A = DictGer.heuristisch_A ;
|
|
hew_V = DictGer.bearbeiten_V ;
|
|
hew_V2 = P.dirV2 (DictGer.bearbeiten_V) ;
|
|
hexagon_N = DictGer.sechseck_N ;
|
|
hibiscus_N = DictGer.hibiskus_N ;
|
|
hick_N = DictGer.landei_N ;
|
|
hideous_A = DictGer.abscheulich_A ;
|
|
hie_V = DictGer.eilen_V ;
|
|
hierarchy_N = DictGer.hierarchie_N ;
|
|
hieroglyph_N = DictGer.hieroglyphe_N ;
|
|
highway_N = DictGer.autobahn_N ;
|
|
hijack_V2 = P.dirV2 (DictGer.entfuehren_V) ;
|
|
hike_N = DictGer.wanderung_N ;
|
|
hill_N = LexiconGer.hill_N ;
|
|
hilt_N = DictGer.griff_N ;
|
|
hinder_V2 = P.dirV2 (DictGer.behindern_V) ;
|
|
hindrance_N = DictGer.behinderung_N ;
|
|
hinge_N = DictGer.angel_N ;
|
|
hint_N = DictGer.hinweis_N ;
|
|
hip_N = DictGer.hagebutte_N ;
|
|
hippie_N = DictGer.hippie_N ;
|
|
historian_N = DictGer.historiker_N ;
|
|
historic_A = DictGer.historisch_A ;
|
|
historical_A = DictGer.historisch_A ;
|
|
history_N = DictGer.erzaehlung_N ;
|
|
histrionic_A = DictGer.pathetisch_A ;
|
|
hit_V = DictGer.morden_V ;
|
|
hit_V2 = LexiconGer.hit_V2 ;
|
|
hitch_N = DictGer.anhaengerkupplung_N ;
|
|
hitchhike_V = DictGer.trampen_V ;
|
|
hitchhiker_N = DictGer.anhalter_N ;
|
|
hive_N = DictGer.bienenstock_N ;
|
|
hoard_N = DictGer.hort_N ;
|
|
hoarse_A = DictGer.heiser_A ;
|
|
hobby_N = DictGer.hobby_N ;
|
|
hodgepodge_N = DictGer.sammelsurium_N ;
|
|
hoe_N = DictGer.hacke_N ;
|
|
hog_N = DictGer.schwein_N ;
|
|
hold_V2 = LexiconGer.hold_V2 ;
|
|
hole_N = DictGer.loch_N ;
|
|
holiday_N = DictGer.feiertag_N ;
|
|
hollow_A = DictGer.hohl_A ;
|
|
holly_N = DictGer.huelse_N ;
|
|
holocaust_N = DictGer.ausloeschung_N ;
|
|
holster_N = DictGer.holster_N ;
|
|
holy_A = DictGer.heilig_A ;
|
|
homage_N = DictGer.hommage_N ;
|
|
home_N = DictGer.heim_N ;
|
|
homeless_A = DictGer.obdachlos_A ;
|
|
homesickness_N = DictGer.nostalgie_N ;
|
|
homicide_N = DictGer.moerder_N ;
|
|
homily_N = DictGer.homilie_N ;
|
|
homo_N = DictGer.homo_N ;
|
|
homogeneity_N = DictGer.homogenitaet_N ;
|
|
homogeneous_A = DictGer.homogen_A ;
|
|
homonym_N = DictGer.homonym_N ;
|
|
homophone_N = DictGer.homophon_N ;
|
|
homosexual_A = DictGer.homosexuell_A ;
|
|
homosexuality_N = DictGer.homosexualitaet_N ;
|
|
hone_N = DictGer.schleifstein_N ;
|
|
honest_A = DictGer.aufrichtig_A ;
|
|
honesty_N = DictGer.silberblatt_N ;
|
|
honey_N = DictGer.honig_N ;
|
|
honeybee_N = DictGer.honigbiene_N ;
|
|
honeycomb_N = DictGer.bienenwabe_N ;
|
|
honeymoon_N = DictGer.hochzeitsreise_N ;
|
|
honk_V = DictGer.hupen_V ;
|
|
honour_N = DictGer.ehre_N ;
|
|
hoof_N = DictGer.huf_N ;
|
|
hook_N = DictGer.haken_N ;
|
|
hookah_N = DictGer.shisha_N ;
|
|
hooker_N = DictGer.dirne_N ;
|
|
hoop_N = DictGer.reif_N ;
|
|
hop_N = DictGer.hopfen_N ;
|
|
hope_N = DictGer.hoffnung_N ;
|
|
horde_N = DictGer.horde_N ;
|
|
horizon_N = DictGer.horizont_N ;
|
|
horizontal_A = DictGer.horizontal_A ;
|
|
hormone_N = DictGer.hormon_N ;
|
|
horn_N = LexiconGer.horn_N ;
|
|
hornbeam_N = DictGer.hainbuche_N ;
|
|
hornet_N = DictGer.hornisse_N ;
|
|
horny_A = DictGer.geil_A ;
|
|
horoscope_N = DictGer.horoskop_N ;
|
|
horse_N = LexiconGer.horse_N ;
|
|
horsefly_N = DictGer.bremse_N ;
|
|
horsepower_N = DictGer.pferdestaerke_N ;
|
|
horseradish_N = DictGer.meerrettich_N ;
|
|
horseshoe_N = DictGer.hufeisen_N ;
|
|
hose_N = DictGer.schlauch_N ;
|
|
hospice_N = DictGer.hospiz_N ;
|
|
hospitable_A = DictGer.gastfreundlich_A ;
|
|
hospital_N = DictGer.krankenhaus_N ;
|
|
hospitality_N = DictGer.bewirtung_N ;
|
|
host_N = DictGer.gastgeber_N ;
|
|
hostage_N = DictGer.geisel_N ;
|
|
hostel_N = DictGer.heim_N ;
|
|
hostile_A = DictGer.feindlich_A ;
|
|
hot_A = LexiconGer.hot_A ;
|
|
hotel_N = DictGer.hotel_N ;
|
|
hothead_N = DictGer.hitzkopf_N ;
|
|
hound_N = DictGer.jagdhund_N ;
|
|
hour_N = DictGer.stunde_N ;
|
|
hourglass_N = DictGer.sanduhr_N ;
|
|
house_N = LexiconGer.house_N ;
|
|
household_N = DictGer.haushalt_N ;
|
|
housekeeper_N = DictGer.hausfrau_N ;
|
|
housewife_N = DictGer.hausfrau_N ;
|
|
housework_N = DictGer.hausarbeit_N ;
|
|
hover_V = DictGer.schweben_V ;
|
|
howitzer_N = DictGer.haubitze_N ;
|
|
hub_N = DictGer.hub_N ;
|
|
hubris_N = DictGer.ueberheblichkeit_N ;
|
|
hue_N = DictGer.farbton_N ;
|
|
hug_N = DictGer.umarmung_N ;
|
|
huge_A = DictGer.riesig_A ;
|
|
hulk_N = DictGer.bulle_N ;
|
|
human_A = DictGer.menschlich_A ;
|
|
humane_A = DictGer.menschlich_A ;
|
|
humanitarian_A = DictGer.humanitaer_A ;
|
|
humanity_N = DictGer.menschlichkeit_N ;
|
|
humble_A = DictGer.bescheiden_A ;
|
|
humerus_N = DictGer.oberarmknochen_N ;
|
|
humidity_N = DictGer.feuchtigkeit_N ;
|
|
humiliate_V2 = P.dirV2 (DictGer.beschaemen_V) ;
|
|
humiliation_N = DictGer.erniedrigung_N ;
|
|
hummingbird_N = DictGer.kolibri_N ;
|
|
humorous_A = DictGer.humorvoll_A ;
|
|
humour_N = DictGer.humor_N ;
|
|
hump_N = DictGer.buckel_N ;
|
|
humpback_N = DictGer.buckel_N ;
|
|
humus_N = DictGer.humus_N ;
|
|
hunch_N = DictGer.ahnung_N ;
|
|
hungarian_A = DictGer.ungarisch_A ;
|
|
hungry_A = DictGer.hungrig_A ;
|
|
hunt_V = DictGer.jagen_V ;
|
|
hunt_V2 = LexiconGer.hunt_V2 ;
|
|
hunter_N = DictGer.jaeger_N ;
|
|
hunting_N = DictGer.jagd_N ;
|
|
hurdle_N = DictGer.hindernis_N ;
|
|
hurl_V2 = P.dirV2 (DictGer.schleudern_V) ;
|
|
hurricane_N = DictGer.hurrikan_N ;
|
|
hurt_V = DictGer.quaelen_V ;
|
|
hurt_V2 = P.dirV2 (DictGer.quaelen_V) ;
|
|
hurtle_V = DictGer.schleudern_V ;
|
|
husband_N = LexiconGer.husband_N ;
|
|
husbandry_N = DictGer.haltung_N ;
|
|
husk_N = DictGer.huelle_N ;
|
|
hussar_N = DictGer.husar_N ;
|
|
hustler_N = DictGer.stricher_N ;
|
|
hybrid_N = DictGer.kreuzung_N ;
|
|
hydrate_N = DictGer.hydrat_N ;
|
|
hydraulics_N = DictGer.hydraulik_N ;
|
|
hydrocarbon_N = DictGer.kohlenwasserstoff_N ;
|
|
hydrofoil_N = DictGer.tragfluegelboot_N ;
|
|
hydrogen_N = DictGer.wasserstoff_N ;
|
|
hyena_N = DictGer.hyaene_N ;
|
|
hygienic_A = DictGer.hygienisch_A ;
|
|
hymen_N = DictGer.jungfernhaeutchen_N ;
|
|
hymn_N = DictGer.hymne_N ;
|
|
hyperbola_N = DictGer.hyperbel_N ;
|
|
hyperbole_N = DictGer.hyperbel_N ;
|
|
hyphen_N = DictGer.bindestrich_N ;
|
|
hypnosis_N = DictGer.hypnose_N ;
|
|
hypochondria_N = DictGer.hypochondrie_N ;
|
|
hypocrisy_N = DictGer.heuchelei_N ;
|
|
hypocrite_N = DictGer.heuchler_N ;
|
|
hypocritical_A = DictGer.heuchlerisch_A ;
|
|
hypotenuse_N = DictGer.hypotenuse_N ;
|
|
hypothesis_N = DictGer.hypothese_N ;
|
|
hypothetical_A = DictGer.hypothetisch_A ;
|
|
hyssop_N = DictGer.ysop_N ;
|
|
hysteria_N = DictGer.hysterie_N ;
|
|
hysterical_A = DictGer.hysterisch_A ;
|
|
iamb_N = DictGer.jambus_N ;
|
|
iambic_A = DictGer.jambisch_A ;
|
|
ibex_N = DictGer.steinbock_N ;
|
|
ibis_N = DictGer.ibis_N ;
|
|
ice_N = LexiconGer.ice_N ;
|
|
iceberg_N = DictGer.eisberg_N ;
|
|
icebreaker_N = DictGer.eisbrecher_N ;
|
|
icicle_N = DictGer.eiszapfen_N ;
|
|
icing_N = DictGer.zuckerguss_N ;
|
|
icon_N = DictGer.bild_N ;
|
|
idea_N = DictGer.ahnung_N ;
|
|
ideal_A = DictGer.ideal_A ;
|
|
idealist_N = DictGer.idealist_N ;
|
|
identical_A = DictGer.identisch_A ;
|
|
identify_V = DictGer.identifizieren_V ;
|
|
identify_V2 = P.dirV2 (DictGer.identifizieren_V) ;
|
|
identikit_N = DictGer.phantombild_N ;
|
|
identity_N = DictGer.gleichheit_N ;
|
|
ideogram_N = DictGer.ideogramm_N ;
|
|
ideological_A = DictGer.ideologisch_A ;
|
|
ideology_N = DictGer.ideologie_N ;
|
|
idiom_N = DictGer.idiom_N ;
|
|
idiomatic_A = DictGer.idiomatisch_A ;
|
|
idiosyncrasy_N = DictGer.eigenart_N ;
|
|
idiosyncratic_A = DictGer.eigenartig_A ;
|
|
idiot_N = DictGer.idiot_N ;
|
|
idiotic_A = DictGer.bloed_A ;
|
|
idle_A = DictGer.muessig_A ;
|
|
idleness_N = DictGer.stillstand_N ;
|
|
idler_N = DictGer.drohne_N ;
|
|
idol_N = DictGer.goetze_N ;
|
|
idyll_N = DictGer.idyll_N ;
|
|
ignite_V = DictGer.zuenden_8_V ;
|
|
ignite_V2 = P.dirV2 (DictGer.zuenden_8_V) ;
|
|
ignoramus_N = DictGer.ignorant_N ;
|
|
ignore_V = DictGer.ignorieren_V ;
|
|
ignore_V2 = P.dirV2 (DictGer.ignorieren_V) ;
|
|
iguana_N = DictGer.leguan_N ;
|
|
ill_A = DictGer.schlecht_A ;
|
|
illegal_A = DictGer.illegal_A ;
|
|
illegitimate_A = DictGer.unrechtmaessig_A ;
|
|
illicit_A = DictGer.verboten_A ;
|
|
illiteracy_N = DictGer.analphabetismus_N ;
|
|
illiterate_A = DictGer.ungebildet_A ;
|
|
illuminate_V2 = P.dirV2 (DictGer.beleuchten_V) ;
|
|
illusion_N = DictGer.illusion_N ;
|
|
illusory_A = DictGer.illusorisch_A ;
|
|
illustrate_V = DictGer.illustrieren_V ;
|
|
illustrate_V2 = P.dirV2 (DictGer.illustrieren_V) ;
|
|
illustration_N = DictGer.illustration_N ;
|
|
image_N = DictGer.bild_N ;
|
|
imaginable_A = DictGer.vorstellbar_A ;
|
|
imagination_N = DictGer.imagination_N ;
|
|
imagine_V = DictGer.vorstellen_V ;
|
|
imagine_V2 = P.dirV2 (DictGer.vorstellen_V) ;
|
|
imbalance_N = DictGer.ungleichgewicht_N ;
|
|
imitation_N = DictGer.imitation_N ;
|
|
immaculate_A = DictGer.makellos_A ;
|
|
immature_A = DictGer.unreif_A ;
|
|
immediate_A = DictGer.sofortig_A ;
|
|
immense_A = DictGer.immens_A ;
|
|
immigration_N = DictGer.einwanderung_N ;
|
|
immodest_A = DictGer.unanstaendig_A ;
|
|
immolate_V2 = P.dirV2 (DictGer.zerstoeren_V) ;
|
|
immortal_A = DictGer.unsterblich_A ;
|
|
immortality_N = DictGer.unsterblichkeit_N ;
|
|
immune_A = DictGer.immun_A ;
|
|
immunity_N = DictGer.immunitaet_N ;
|
|
immunize_V2 = P.dirV2 (DictGer.immunisieren_V) ;
|
|
immutable_A = DictGer.unveraenderbar_A ;
|
|
impact_N = DictGer.aufprall_N ;
|
|
impala_N = DictGer.impala_N ;
|
|
impart_V2 = P.dirV2 (DictGer.gewaehren_V) ;
|
|
impartial_A = DictGer.unparteiisch_A ;
|
|
impasse_N = DictGer.sackgasse_N ;
|
|
impassive_A = DictGer.gleichmuetig_A ;
|
|
impeccable_A = DictGer.makellos_A ;
|
|
impede_V2 = P.dirV2 (DictGer.behindern_V) ;
|
|
impediment_N = DictGer.behinderung_N ;
|
|
impend_V = DictGer.drohen_V ;
|
|
imperialism_N = DictGer.imperialismus_N ;
|
|
imperialistic_A = DictGer.imperialistisch_A ;
|
|
imperious_A = DictGer.koeniglich_A ;
|
|
impertinent_A = DictGer.unverschaemt_A ;
|
|
impervious_A = DictGer.gleichgueltig_A ;
|
|
impetuous_A = DictGer.ungestuem_A ;
|
|
implementation_N = DictGer.implementierung_N ;
|
|
implication_N = DictGer.bedeutung_N ;
|
|
implicit_A = DictGer.implizit_A ;
|
|
imply_V = DictGer.bedeuten_V ;
|
|
imply_V2 = P.dirV2 (DictGer.bedeuten_V) ;
|
|
impolite_A = DictGer.unhoeflich_A ;
|
|
import_N = DictGer.einfuhr_N ;
|
|
importance_N = DictGer.belang_N ;
|
|
important_A = LexiconGer.important_A ;
|
|
importer_N = DictGer.importeur_N ;
|
|
importune_V2 = P.dirV2 (DictGer.bedraengen_V) ;
|
|
impossible_A = DictGer.unmoeglich_A ;
|
|
impostor_N = DictGer.betrueger_N ;
|
|
impractical_A = DictGer.untauglich_A ;
|
|
impregnate_V2 = P.dirV2 (DictGer.impraegnieren_V) ;
|
|
impression_N = DictGer.eindruck_N ;
|
|
impressionist_N = DictGer.impressionist_N ;
|
|
impressive_A = DictGer.eindrucksvoll_A ;
|
|
imprint_N = DictGer.aufdruck_N ;
|
|
imprisonment_N = DictGer.gefangenschaft_N ;
|
|
improper_A = DictGer.unpassend_A ;
|
|
improve_V = DictGer.verbessern_V ;
|
|
improve_V2 = P.dirV2 (DictGer.verbessern_V) ;
|
|
improvement_N = DictGer.verbesserung_N ;
|
|
improvisation_N = DictGer.improvisation_N ;
|
|
improvise_V = DictGer.improvisieren_V ;
|
|
improvise_V2 = P.dirV2 (DictGer.improvisieren_V) ;
|
|
impudence_N = DictGer.frechheit_N ;
|
|
impudent_A = DictGer.frech_A ;
|
|
impulse_N = DictGer.impuls_N ;
|
|
impulsive_A = DictGer.impulsiv_A ;
|
|
impurity_N = DictGer.fremdkoerper_N ;
|
|
inadequate_A = DictGer.unangemessen_A ;
|
|
inadvertent_A = DictGer.unbeabsichtigt_A ;
|
|
inalienable_A = DictGer.unabdingbar_A ;
|
|
inane_A = DictGer.sinnlos_A ;
|
|
inanimate_A = DictGer.unbelebt_A ;
|
|
inappropriate_A = DictGer.unangebracht_A ;
|
|
inaudible_A = DictGer.unhoerbar_A ;
|
|
inauguration_N = DictGer.inauguration_N ;
|
|
inauspicious_A = DictGer.unguenstig_A ;
|
|
inborn_A = DictGer.angeboren_A ;
|
|
incense_N = DictGer.weihrauch_N ;
|
|
incentive_N = DictGer.anreiz_N ;
|
|
incest_N = DictGer.inzest_N ;
|
|
inch_N = DictGer.zoll_N ;
|
|
incident_N = DictGer.begebenheit_N ;
|
|
incisor_N = DictGer.schneidezahn_N ;
|
|
inclination_N = DictGer.neigung_N ;
|
|
incline_V = DictGer.neigen_V ;
|
|
incline_V2 = P.dirV2 (DictGer.neigen_V) ;
|
|
incoherent_A = DictGer.inkohaerent_A ;
|
|
income_N = DictGer.einkommen_N ;
|
|
incompatibility_N = DictGer.inkompatibilitaet_N ;
|
|
incompetent_A = DictGer.inkompetent_A ;
|
|
incomplete_A = DictGer.unvollstaendig_A ;
|
|
incomprehensible_A = DictGer.unverstaendlich_A ;
|
|
inconceivable_A = DictGer.unfassbar_A ;
|
|
incongruous_A = DictGer.disparat_A ;
|
|
inconspicuous_A = DictGer.unauffaellig_A ;
|
|
inconvenience_N = DictGer.unannehmlichkeit_N ;
|
|
inconvenient_A = DictGer.laestig_A ;
|
|
increase_V = DictGer.erhoehen_V ;
|
|
increase_V2 = P.dirV2 (DictGer.erhoehen_V) ;
|
|
incredible_A = DictGer.unglaublich_A ;
|
|
incredulous_A = DictGer.skeptisch_A ;
|
|
increment_N = DictGer.erhoehung_N ;
|
|
incremental_A = DictGer.inkremental_A ;
|
|
incriminate_V2 = P.dirV2 (DictGer.belasten_V) ;
|
|
incubator_N = DictGer.brutkasten_N ;
|
|
incubus_N = DictGer.alptraum_N ;
|
|
indecent_A = DictGer.unanstaendig_A ;
|
|
indefatigable_A = DictGer.unermuedlich_A ;
|
|
indentation_N = DictGer.einrueckung_N ;
|
|
independence_N = DictGer.unabhaengigkeit_N ;
|
|
independent_A = DictGer.unabhaengig_A ;
|
|
index_N = DictGer.verzeichnis_N ;
|
|
indicator_N = DictGer.blinker_N ;
|
|
indifferent_A = DictGer.gleichgueltig_A ;
|
|
indigenous_A = DictGer.indigen_A ;
|
|
indignation_N = DictGer.entruestung_N ;
|
|
indiscriminate_A = DictGer.gedankenlos_A ;
|
|
indispensable_A = DictGer.unabdingbar_A ;
|
|
individual_N = DictGer.individuum_N ;
|
|
indoctrinate_V2 = P.dirV2 (DictGer.indoktrinieren_V) ;
|
|
indoctrination_N = DictGer.indoktrination_N ;
|
|
induction_N = DictGer.induktion_N ;
|
|
indulge_V = DictGer.froenen_V ;
|
|
indulge_V2 = P.dirV2 (DictGer.froenen_V) ;
|
|
indulgence_N = DictGer.ablass_N ;
|
|
industrial_A = DictGer.industriell_A ;
|
|
industrialization_N = DictGer.industrialisierung_N ;
|
|
industrious_A = DictGer.eifrig_A ;
|
|
industry_N = LexiconGer.industry_N ;
|
|
ineffective_A = DictGer.unfaehig_A ;
|
|
inept_A = DictGer.unfaehig_A ;
|
|
inequality_N = DictGer.ungleichheit_N ;
|
|
inescapable_A = DictGer.unumgaenglich_A ;
|
|
inevitable_A = DictGer.zwangslaeufig_A ;
|
|
inexhaustible_A = DictGer.unerschoepflich_A ;
|
|
inexpensive_A = DictGer.billig_A ;
|
|
inexperienced_A = DictGer.unerfahren_A ;
|
|
infallible_A = DictGer.unfehlbar_A ;
|
|
infamous_A = DictGer.beruechtigt_A ;
|
|
infancy_N = DictGer.anfangsphase_N ;
|
|
infant_N = DictGer.baby_N ;
|
|
infantry_N = DictGer.infanterie_N ;
|
|
infantryman_N = DictGer.infanterist_N ;
|
|
infatuate_V2 = P.dirV2 (DictGer.betoeren_V) ;
|
|
infect_V = DictGer.infizieren_V ;
|
|
infect_V2 = P.dirV2 (DictGer.infizieren_V) ;
|
|
infection_N = DictGer.ansteckung_N ;
|
|
infectious_A = DictGer.ansteckend_A ;
|
|
inferno_N = DictGer.hoelle_N ;
|
|
infiltration_N = DictGer.infiltration_N ;
|
|
infinite_A = DictGer.unendlich_A ;
|
|
infinitive_N = DictGer.infinitiv_N ;
|
|
inflame_V = DictGer.erzuernen_V ;
|
|
inflame_V2 = P.dirV2 (DictGer.erzuernen_V) ;
|
|
inflammable_A = DictGer.brennbar_A ;
|
|
inflammation_N = DictGer.entzuendung_N ;
|
|
inflammatory_A = DictGer.aufruehrerisch_A ;
|
|
inflation_N = DictGer.inflation_N ;
|
|
inflection_N = DictGer.beugung_N ;
|
|
inflorescence_N = DictGer.bluetenstand_N ;
|
|
influence_N = DictGer.einfluss_N ;
|
|
influenza_N = DictGer.grippe_N ;
|
|
inform_V = DictGer.informieren_V ;
|
|
inform_V2 = P.dirV2 (DictGer.informieren_V) ;
|
|
informal_A = DictGer.informell_A ;
|
|
informant_N = DictGer.informant_N ;
|
|
information_N = DictGer.auskunft_N ;
|
|
informer_N = DictGer.informant_N ;
|
|
infrastructure_N = DictGer.infrastruktur_N ;
|
|
infringement_N = DictGer.verletzung_N ;
|
|
ingot_N = DictGer.barren_N ;
|
|
ingress_N = DictGer.eingang_N ;
|
|
inhabitant_N = DictGer.bewohner_N ;
|
|
inhalation_N = DictGer.inhalation_N ;
|
|
inhale_V = DictGer.inhalieren_V ;
|
|
inhale_V2 = P.dirV2 (DictGer.inhalieren_V) ;
|
|
inherent_A = DictGer.inhaerent_A ;
|
|
inherit_V = DictGer.erben_V ;
|
|
inherit_V2 = P.dirV2 (DictGer.erben_V) ;
|
|
inheritance_N = DictGer.erbschaft_N ;
|
|
inhibit_V2 = P.dirV2 (DictGer.hemmen_V) ;
|
|
inhuman_A = DictGer.unmenschlich_A ;
|
|
inhumane_A = DictGer.unmenschlich_A ;
|
|
inimical_A = DictGer.feindlich_A ;
|
|
initial_A = DictGer.anfaenglich_A ;
|
|
initiation_N = DictGer.initiierung_N ;
|
|
initiative_N = DictGer.initiative_N ;
|
|
inject_V2 = P.dirV2 (DictGer.injizieren_V) ;
|
|
injection_N = DictGer.injektion_N ;
|
|
injure_V2 = P.dirV2 (DictGer.verletzen_V) ;
|
|
injury_N = DictGer.verletzung_N ;
|
|
ink_N = DictGer.tinte_N ;
|
|
inkling_N = DictGer.ahnung_N ;
|
|
inkstand_N = DictGer.schreibzeug_N ;
|
|
inkwell_N = DictGer.tintenfass_N ;
|
|
inn_N = DictGer.gasthaus_N ;
|
|
innocuous_A = DictGer.harmlos_A ;
|
|
innovation_N = DictGer.innovation_N ;
|
|
innuendo_N = DictGer.anspielung_N ;
|
|
inoculation_N = DictGer.impfung_N ;
|
|
input_N = DictGer.eingabe_N ;
|
|
inquiry_N = DictGer.anfrage_N ;
|
|
insane_A = DictGer.geisteskrank_A ;
|
|
inscription_N = DictGer.inschrift_N ;
|
|
insect_N = DictGer.insekt_N ;
|
|
insecurity_N = DictGer.unsicherheit__N ;
|
|
insemination_N = DictGer.befruchtung_N ;
|
|
insensate_A = DictGer.unsinnig_A ;
|
|
inside_N = DictGer.innenseite_N ;
|
|
insight_N = DictGer.einsicht_N ;
|
|
insignificant_A = DictGer.bedeutungslos_A ;
|
|
insipid_A = DictGer.fade_A ;
|
|
insist_V = DictGer.bestehen_V ;
|
|
insist_V2 = P.dirV2 (DictGer.bestehen_V) ;
|
|
insolvency_N = DictGer.insolvenz_N ;
|
|
insomnia_N = DictGer.insomnia_N ;
|
|
inspect_V2 = P.dirV2 (DictGer.pruefen_8_V) ;
|
|
inspection_N = DictGer.inspektion_N ;
|
|
inspiration_N = DictGer.inspiration__N ;
|
|
install_V = DictGer.installieren_V ;
|
|
install_V2 = P.dirV2 (DictGer.installieren_V) ;
|
|
instance_N = DictGer.instanz_N ;
|
|
instant_N = DictGer.augenblick_N ;
|
|
instantaneous_A = DictGer.augenblicklich_A ;
|
|
instinct_N = DictGer.instinkt_N ;
|
|
institute_N = DictGer.institut_N ;
|
|
institution_N = DictGer.institution_N ;
|
|
instruction_N = DictGer.instruction_N ;
|
|
instructor_N = DictGer.ausbilder_N ;
|
|
instrument_N = DictGer.dokument_N ;
|
|
insulate_V2 = P.dirV2 (DictGer.isolieren_3_V) ;
|
|
insulator_N = DictGer.isolator_N ;
|
|
insulin_N = DictGer.insulin_N ;
|
|
insult_V2 = P.dirV2 (DictGer.beleidigen_V) ;
|
|
insurance_N = DictGer.versicherung_N ;
|
|
insure_V = DictGer.versichern_V ;
|
|
insure_V2 = P.dirV2 (DictGer.versichern_V) ;
|
|
insurrection_N = DictGer.aufstand_N ;
|
|
integer_N = DictGer.ganzzahl_N ;
|
|
integrate_V = DictGer.integrieren_V ;
|
|
integrate_V2 = P.dirV2 (DictGer.integrieren_V) ;
|
|
integration_N = DictGer.integration_N ;
|
|
intellect_N = DictGer.intellekt_N ;
|
|
intellectual_A = DictGer.intellektuell_A ;
|
|
intelligence_N = DictGer.intelligenz_N ;
|
|
intelligent_A = DictGer.intelligent_A ;
|
|
intelligentsia_N = DictGer.intelligenz_N ;
|
|
intelligible_A = DictGer.verstaendlich_A ;
|
|
intend_V = DictGer.beabsichtigen_V ;
|
|
intend_V2 = P.dirV2 (DictGer.beabsichtigen_V) ;
|
|
intense_A = DictGer.intensiv_A ;
|
|
intensity_N = DictGer.intensitaet_N ;
|
|
intent_N = DictGer.absicht_N ;
|
|
intention_N = DictGer.absicht_N ;
|
|
intentional_A = DictGer.absichtlich_A ;
|
|
inter_V2 = P.dirV2 (DictGer.begraben_V) ;
|
|
interaction_N = DictGer.interaktion_N ;
|
|
interactive_A = DictGer.interaktiv_A ;
|
|
interbreed_V = DictGer.begraben_V ;
|
|
interbreed_V2 = P.dirV2 (DictGer.begraben_V) ;
|
|
intercontinental_A = DictGer.interkontinental_A ;
|
|
interdisciplinary_A = DictGer.interdisziplinaer_A ;
|
|
interest_N = DictGer.interesse_N ;
|
|
interested_A = DictGer.interessiert_A ;
|
|
interesting_A = DictGer.interessant_A ;
|
|
interface_N = DictGer.schnittstelle_N ;
|
|
interference_N = DictGer.interferenz_N ;
|
|
interjection_N = DictGer.interjektion_N ;
|
|
interlocutor_N = DictGer.gespraechspartner_N ;
|
|
intermission_N = DictGer.pause_N ;
|
|
intern_V2 = P.dirV2 (DictGer.internieren_V) ;
|
|
international_A = DictGer.international_A ;
|
|
internationalism_N = DictGer.internationalismus_N ;
|
|
interplanetary_A = DictGer.interplanetar_A ;
|
|
interpret_V = DictGer.dolmetschen_V ;
|
|
interpret_V2 = P.dirV2 (DictGer.dolmetschen_V) ;
|
|
interpretation_N = DictGer.interpretation_N ;
|
|
interpreter_N = DictGer.dolmetscher_N ;
|
|
interregnum_N = DictGer.pause_N ;
|
|
interrelation_N = DictGer.zusammenhang_N ;
|
|
interrogate_V2 = P.dirV2 (DictGer.verhoeren_V) ;
|
|
interrupt_V = DictGer.unterbrechen_V ;
|
|
interrupt_V2 = P.dirV2 (DictGer.unterbrechen_V) ;
|
|
interruption_N = DictGer.unterbrechung_N ;
|
|
intersection_N = DictGer.durchschnitt_N ;
|
|
interstellar_A = DictGer.interstellar_A ;
|
|
interval_N = DictGer.abstand_N ;
|
|
intervention_N = DictGer.intervention_N ;
|
|
interview_N = DictGer.interview_N ;
|
|
interviewer_N = DictGer.befrager_N ;
|
|
interweave_V2 = P.dirV2 (DictGer.begraben_V) ;
|
|
intestine_N = DictGer.darm_N ;
|
|
intimacy_N = DictGer.intimitaet_N ;
|
|
intimate_A = DictGer.innig_A ;
|
|
intimidate_V2 = P.dirV2 (DictGer.beeindrucken_V) ;
|
|
intolerance_N = DictGer.intoleranz_N ;
|
|
intolerant_A = DictGer.intolerant_A ;
|
|
intonation_N = DictGer.intonation_N ;
|
|
intoxicate_V2 = P.dirV2 (DictGer.vergiften_V) ;
|
|
intransigent_A = DictGer.intransigent_A ;
|
|
intransitive_A = DictGer.intransitiv_A ;
|
|
intravenous_A = DictGer.intravenoes_A ;
|
|
intrepid_A = DictGer.furchtlos_A ;
|
|
intricacy_N = DictGer.schwierigkeit_N ;
|
|
intricate_A = DictGer.aufwendig_A ;
|
|
intrigue_N = DictGer.intrige_N ;
|
|
intrinsic_A = DictGer.intrinsisch_A ;
|
|
introduce_V2 = P.dirV2 (DictGer.vorstellen_V) ;
|
|
introduction_N = DictGer.einfuehrung_N ;
|
|
intrude_V = DictGer.stoeren_V ;
|
|
intrude_V2 = P.dirV2 (DictGer.stoeren_V) ;
|
|
intruder_N = DictGer.eindringling_N ;
|
|
intuition_N = DictGer.ahnung_N ;
|
|
intuitive_A = DictGer.intuitiv_A ;
|
|
inure_V2 = P.dirV2 (DictGer.gewoehnen_8_V) ;
|
|
invade_V2 = P.dirV2 (DictGer.verletzen_V) ;
|
|
invalid_A = DictGer.ungueltig_A ;
|
|
invasion_N = DictGer.invasion_N ;
|
|
invent_V = DictGer.erfinden_V ;
|
|
invent_V2 = P.dirV2 (DictGer.erfinden_V) ;
|
|
invention_N = DictGer.erfindung_N ;
|
|
inventor_N = DictGer.erfinder_N ;
|
|
inventory_N = DictGer.inventar_N ;
|
|
inverse_A = DictGer.entgegengesetzt_A ;
|
|
invest_V = DictGer.investieren_V ;
|
|
invest_V2 = P.dirV2 (DictGer.investieren_V) ;
|
|
investigate_V = DictGer.untersuchen_V ;
|
|
investigate_V2 = P.dirV2 (DictGer.untersuchen_V) ;
|
|
investigation_N = DictGer.untersuchung_N ;
|
|
investment_N = DictGer.investition_N ;
|
|
investor_N = DictGer.investor_N ;
|
|
invigorate_V2 = P.dirV2 (DictGer.beleben_V) ;
|
|
invisible_A = DictGer.unsichtbar_A ;
|
|
invitation_N = DictGer.einladung_N ;
|
|
invoice_N = DictGer.rechnung_N ;
|
|
involuntary_A = DictGer.unfreiwillig_A ;
|
|
invulnerable_A = DictGer.unverwundbar_A ;
|
|
ion_N = DictGer.ion_N ;
|
|
ionosphere_N = DictGer.ionosphaere_N ;
|
|
iota_N = DictGer.jota_N ;
|
|
iridescent_A = DictGer.irisierend_A ;
|
|
iris_N = DictGer.regenbogenhaut_N ;
|
|
iron_N = LexiconGer.iron_N ;
|
|
ironic_A = DictGer.ironisch_A ;
|
|
ironical_A = DictGer.ironisch_A ;
|
|
irony_N = DictGer.ironie_N ;
|
|
irrational_A = DictGer.irrational_A ;
|
|
irrelevant_A = DictGer.irrelevant_A ;
|
|
irresistible_A = DictGer.unwiderstehlich_A ;
|
|
irresponsible_A = DictGer.verantwortungslos_A ;
|
|
irreverent_A = DictGer.respektlos_A ;
|
|
irrigate_V2 = P.dirV2 (DictGer.bewaessern_V) ;
|
|
irrigation_N = DictGer.irrigation_N ;
|
|
irritate_V2 = P.dirV2 (DictGer.reizen_5_V) ;
|
|
island_N = DictGer.eiland_N ;
|
|
islander_N = DictGer.insulaner_N ;
|
|
isobar_N = DictGer.isobare_N ;
|
|
isolate_V2 = P.dirV2 (DictGer.isolieren_3_V) ;
|
|
isolation_N = DictGer.isolierung_N ;
|
|
isosceles_A = DictGer.gleichschenklig_A ;
|
|
isotherm_N = DictGer.isotherme_N ;
|
|
isotope_N = DictGer.isotop_N ;
|
|
isthmus_N = DictGer.isthmus_N ;
|
|
italian_A = DictGer.italienisch_A ;
|
|
italic_A = DictGer.kursiv_A ;
|
|
itch_N = DictGer.itch_N ;
|
|
item_N = DictGer.artikel_N ;
|
|
iteration_N = DictGer.iteration_N ;
|
|
itinerary_N = DictGer.reisefuehrer_N ;
|
|
jack_N = DictGer.bube_N ;
|
|
jackal_N = DictGer.schakal_N ;
|
|
jackass_N = DictGer.esel_N ;
|
|
jackdaw_N = DictGer.dohle_N ;
|
|
jacket_N = DictGer.jacke_N ;
|
|
jackpot_N = DictGer.jackpot_N ;
|
|
jade_N = DictGer.maehre_N ;
|
|
jaguar_N = DictGer.jaguar_N ;
|
|
jailer_N = DictGer.gefaengniswaerter_N ;
|
|
jam_N = DictGer.konfituere_N ;
|
|
janitor_N = DictGer.hausmeister_N ;
|
|
japanese_A = DictGer.japanisch_A ;
|
|
jaw_N = DictGer.kiefer_N ;
|
|
jawbone_N = DictGer.kiefer_N ;
|
|
jay_N = DictGer.haeher_N ;
|
|
jealous_A = DictGer.eifersuechtig_A ;
|
|
jeep_N = DictGer.jeep_N ;
|
|
jeer_N = DictGer.fall_N ;
|
|
jelly_N = DictGer.marmelade_N ;
|
|
jellyfish_N = DictGer.qualle_N ;
|
|
jerk_N = DictGer.arsch_N ;
|
|
jersey_N = DictGer.trikot_N ;
|
|
jester_N = DictGer.hofnarr_N ;
|
|
jet_N = DictGer.jet_N ;
|
|
jewel_N = DictGer.edelstein_N ;
|
|
jewellery_N = DictGer.schmuck_N ;
|
|
jiffy_N = DictGer.augenblick_N ;
|
|
jig_N = DictGer.schablone_N ;
|
|
job_N = DictGer.anstellung_N ;
|
|
jockey_N = DictGer.jockey_N ;
|
|
jocose_A = DictGer.drollig_A ;
|
|
jocular_A = DictGer.scherzhaft_A ;
|
|
joiner_N = DictGer.bindeglied_N ;
|
|
joist_N = DictGer.balken_N ;
|
|
joke_N = DictGer.scherz_N ;
|
|
joker_N = DictGer.joker_N ;
|
|
jordanian_N = DictGer.jordanier_N ;
|
|
joule_N = DictGer.joule_N ;
|
|
journalist_N = DictGer.journalist_N ;
|
|
journey_N = DictGer.reise_N ;
|
|
journeyman_N = DictGer.wandergeselle_N ;
|
|
jovial_A = DictGer.froehlich_A ;
|
|
jowl_N = DictGer.backe_N ;
|
|
joy_N = DictGer.freude_N ;
|
|
joyful_A = DictGer.erfreulich_A ;
|
|
judge_N = DictGer.richter_N ;
|
|
jug_N = DictGer.kanne_N ;
|
|
juggle_V = DictGer.jonglieren_V ;
|
|
juggle_V2 = P.dirV2 (DictGer.jonglieren_V) ;
|
|
juggler_N = DictGer.jongleur_N ;
|
|
juice_N = DictGer.saft_N ;
|
|
jukebox_N = DictGer.musikbox_N ;
|
|
jump_V = LexiconGer.jump_V ;
|
|
jump_V2 = P.dirV2 (DictGer.springen_7_V) ;
|
|
jumper_N = DictGer.springer_N ;
|
|
junction_N = DictGer.knotenpunkt_N ;
|
|
juniper_N = DictGer.wacholder_N ;
|
|
junk_N = DictGer.abfall_N ;
|
|
juridical_A = DictGer.juristisch_A ;
|
|
jurisdiction_N = DictGer.jurisdiktion_N ;
|
|
jurisprudence_N = DictGer.rechtsprechung_N ;
|
|
jurist_N = DictGer.jurist_N ;
|
|
jury_N = DictGer.jury_N ;
|
|
justice_N = DictGer.gerechtigkeit_N ;
|
|
justification_N = DictGer.rechtfertigung_N ;
|
|
justify_V2 = P.dirV2 (DictGer.justieren_V) ;
|
|
kangaroo_N = DictGer.kaenguru_N ;
|
|
keel_N = DictGer.kiel_N ;
|
|
keep_V = DictGer.behalten_4_V ;
|
|
keep_V2 = P.dirV2 (DictGer.behalten_4_V) ;
|
|
keg_N = DictGer.fass_N ;
|
|
kennel_N = DictGer.hundehuette_N ;
|
|
kepi_N = DictGer.kaeppi_N ;
|
|
kerchief_N = DictGer.kopftuch_N ;
|
|
kernel_N = DictGer.kern_N ;
|
|
kestrel_N = DictGer.falke_N ;
|
|
kettle_N = DictGer.kessel_N ;
|
|
key_N = DictGer.schluessel_N ;
|
|
keyboard_N = DictGer.keyboard_N ;
|
|
keyhole_N = DictGer.schluesselloch_N ;
|
|
keystone_N = DictGer.schlussstein_N ;
|
|
keyword_N = DictGer.schluessel_N ;
|
|
khan_N = DictGer.khan_N ;
|
|
kick_V = DictGer.kicken_V ;
|
|
kick_V2 = P.dirV2 (DictGer.kicken_V) ;
|
|
kid_N = DictGer.kind_N ;
|
|
kidnap_V2 = P.dirV2 (DictGer.entfuehren_V) ;
|
|
kidney_N = DictGer.niere_N ;
|
|
kill_N = DictGer.opfer_N ;
|
|
kill_V2 = LexiconGer.kill_V2 ;
|
|
killer_N = DictGer.moerder_N ;
|
|
kilogram_N = DictGer.kilogramm_N ;
|
|
kilometre_N = DictGer.kilometer_N ;
|
|
kind_A = DictGer.aufmerksam_A ;
|
|
kindergarten_N = DictGer.kindergarten_N ;
|
|
kindness_N = DictGer.liebenswuerdigkeit_N ;
|
|
king_N = LexiconGer.king_N ;
|
|
kingdom_N = DictGer.koenigreich_N ;
|
|
kingfisher_N = DictGer.eisvogel_N ;
|
|
kinship_N = DictGer.verwandtschaft_N ;
|
|
kiosk_N = DictGer.kiosk_N ;
|
|
kirsch_N = DictGer.kirschwasser_N ;
|
|
kiss_V = DictGer.kuessen_9_V ;
|
|
kiss_V2 = P.dirV2 (DictGer.kuessen_9_V) ;
|
|
kitchen_N = DictGer.kueche_N ;
|
|
kite_N = DictGer.drachen_N ;
|
|
kitten_N = DictGer.kaetzchen_N ;
|
|
kitty_N = DictGer.kaetzchen_N ;
|
|
kiwi_N = DictGer.kiwi_N ;
|
|
kleptomania_N = DictGer.kleptomanie_N ;
|
|
knave_N = DictGer.boy_N ;
|
|
knavery_N = DictGer.gaunerei_N ;
|
|
knead_V = DictGer.kneten_V ;
|
|
knead_V2 = P.dirV2 (DictGer.kneten_V) ;
|
|
knee_N = LexiconGer.knee_N ;
|
|
kneecap_N = DictGer.kniescheibe_N ;
|
|
kneel_V = DictGer.knien_V ;
|
|
knife_N = DictGer.messer_N ;
|
|
knight_N = DictGer.ritter_N ;
|
|
knock_N = DictGer.schlag_N ;
|
|
knot_N = DictGer.ast_N ;
|
|
know_V = DictGer.erkennen_2_V ;
|
|
know_V2 = LexiconGer.know_V2 ;
|
|
knowledge_N = DictGer.kenntnis_N ;
|
|
knuckle_N = DictGer.fingerknoechel_N ;
|
|
koala_N = DictGer.koala_N ;
|
|
kohlrabi_N = DictGer.kohlrabi_N ;
|
|
kosher_A = DictGer.koscher_A ;
|
|
kowtow_V = DictGer.knien_V ;
|
|
krona_N = DictGer.krone_N ;
|
|
krone_N = DictGer.krone_N ;
|
|
labial_A = DictGer.labial_A ;
|
|
laboratory_N = DictGer.laboratorium_N ;
|
|
labour_N = DictGer.arbeit_N ;
|
|
labyrinth_N = DictGer.labyrinth_N ;
|
|
lace_N = DictGer.spitze_N ;
|
|
lachrymose_A = DictGer.traurig_A ;
|
|
lack_N = DictGer.mangel_N ;
|
|
lackey_N = DictGer.lakai_N ;
|
|
laconic_A = DictGer.lakonisch_A ;
|
|
lacquer_N = DictGer.lack_N ;
|
|
lad_N = DictGer.bursche_N ;
|
|
ladder_N = DictGer.leiter_N ;
|
|
ladle_N = DictGer.schoepfkelle_N ;
|
|
lady_N = DictGer.dame_N ;
|
|
ladybird_N = DictGer.marienkaefer_N ;
|
|
lagoon_N = DictGer.lagune_N ;
|
|
lake_N = LexiconGer.lake_N ;
|
|
lama_N = DictGer.lama_N ;
|
|
lamb_N = DictGer.lamm_N ;
|
|
lamp_N = LexiconGer.lamp_N ;
|
|
lamprey_N = DictGer.neunauge_N ;
|
|
lampshade_N = DictGer.lampenschirm_N ;
|
|
lance_N = DictGer.harpune_N ;
|
|
landfall_N = DictGer.landung_N ;
|
|
landing_N = DictGer.landung_N ;
|
|
landlady_N = DictGer.vermieterin_N ;
|
|
landlord_N = DictGer.hauswirt_N ;
|
|
landlubber_N = DictGer.landratte_N ;
|
|
landmark_N = DictGer.sehenswuerdigkeit_N ;
|
|
landscape_N = DictGer.landschaft_N ;
|
|
landslide_N = DictGer.erdrutsch_N ;
|
|
lane_N = DictGer.gang_N ;
|
|
language_N = LexiconGer.language_N ;
|
|
languish_V = DictGer.schmachten_V ;
|
|
lantern_N = DictGer.laterne_N ;
|
|
lap_N = DictGer.schoss_0_N ;
|
|
lapwing_N = DictGer.kiebitz_N ;
|
|
larboard_N = DictGer.backbord_N ;
|
|
larch_N = DictGer.laerche_N ;
|
|
lard_N = DictGer.schmalz_N ;
|
|
larder_N = DictGer.speisekammer_N ;
|
|
large_A = DictGer.weit_A ;
|
|
lark_N = DictGer.fruehaufsteher_N ;
|
|
larva_N = DictGer.larve_N ;
|
|
larynx_N = DictGer.kehlkopf_N ;
|
|
lascivious_A = DictGer.lasziv_A ;
|
|
laser_N = DictGer.laser_N ;
|
|
lass_N = DictGer.jungfrau_N ;
|
|
late_A = DictGer.spaet_A ;
|
|
latent_A = DictGer.latent_A ;
|
|
latitude_N = DictGer.breite_N ;
|
|
latrine_N = DictGer.latrine_N ;
|
|
lattice_N = DictGer.verband_N ;
|
|
laudable_A = DictGer.lobenswert_A ;
|
|
laugh_V = LexiconGer.laugh_V ;
|
|
laughter_N = DictGer.gelaechter_N ;
|
|
launch_V = DictGer.lancieren_V ;
|
|
launch_V2 = P.dirV2 (DictGer.lancieren_V) ;
|
|
laundry_N = DictGer.waschkueche_N ;
|
|
laurel_N = DictGer.lorbeer_N ;
|
|
lavatory_N = DictGer.abort_N ;
|
|
lavender_N = DictGer.lavendel_N ;
|
|
law_N = DictGer.gesetz_N ;
|
|
lawmaker_N = DictGer.gesetzgeber_N ;
|
|
lawn_N = DictGer.rasen_N ;
|
|
lawyer_N = DictGer.rechtsanwalt_N ;
|
|
lay_V = DictGer.legen_4_V ;
|
|
lay_V2 = P.dirV2 (DictGer.legen_4_V) ;
|
|
layabout_N = DictGer.faulenzer_N ;
|
|
layer_N = DictGer.lage_N ;
|
|
layman_N = DictGer.laie_N ;
|
|
layover_N = DictGer.aufenthalt_N ;
|
|
lazy_A = DictGer.faul_A ;
|
|
lazybones_N = DictGer.faulpelz_N ;
|
|
lead_N = DictGer.ader_N ;
|
|
leader_N = DictGer.anfuehrer_N ;
|
|
leaf_N = LexiconGer.leaf_N ;
|
|
leaflet_N = DictGer.broschuere_N ;
|
|
league_N = DictGer.bund_N ;
|
|
leak_N = DictGer.leck_N ;
|
|
lean_V = DictGer.lehnen_6_V ;
|
|
lean_V2 = P.dirV2 (DictGer.lehnen_6_V) ;
|
|
leapfrog_N = DictGer.bockspringen_N ;
|
|
learn_V = DictGer.erfahren_V ;
|
|
learn_V2 = LexiconGer.learn_V2 ;
|
|
learner_N = DictGer.lerner_N ;
|
|
lease_V2 = P.dirV2 (DictGer.pachten_V) ;
|
|
leaseholder_N = DictGer.paechter_N ;
|
|
leash_N = DictGer.hundeleine_N ;
|
|
leather_N = LexiconGer.leather_N ;
|
|
leave_V = DictGer.lassen_3_V ;
|
|
leave_V2 = LexiconGer.leave_V2 ;
|
|
leaven_N = DictGer.treibmittel_N ;
|
|
lecher_N = DictGer.lustmolch_N ;
|
|
lecherous_A = DictGer.luestern_A ;
|
|
lechery_N = DictGer.wollust_N ;
|
|
lecture_N = DictGer.vorlesung_N ;
|
|
lecturer_N = DictGer.lektor_N ;
|
|
ledge_N = DictGer.ader_N ;
|
|
leech_N = DictGer.blutegel_N ;
|
|
leek_N = DictGer.porree_N ;
|
|
left_A = DictGer.uebrig_A ;
|
|
leg_N = LexiconGer.leg_N ;
|
|
legal_A = DictGer.juristisch_A ;
|
|
legalization_N = DictGer.legalisierung_N ;
|
|
legend_N = DictGer.legende_N ;
|
|
legendary_A = DictGer.legendaer_A ;
|
|
legible_A = DictGer.leserlich_A ;
|
|
legislation_N = DictGer.gesetz_N ;
|
|
legislator_N = DictGer.gesetzgeber_N ;
|
|
legislature_N = DictGer.legislative_N ;
|
|
legitimate_A = DictGer.gueltig_A ;
|
|
leisure_N = DictGer.freizeit_N ;
|
|
lemming_N = DictGer.lemming_N ;
|
|
lemon_N = DictGer.zitrone_N ;
|
|
lemonade_N = DictGer.brause_N ;
|
|
lemur_N = DictGer.lemur_N ;
|
|
lend_V = DictGer.borgen_V ;
|
|
lend_V2 = P.dirV2 (DictGer.borgen_V) ;
|
|
length_N = DictGer.laenge_N ;
|
|
lengthen_V = DictGer.verlaengern_V ;
|
|
lengthen_V2 = P.dirV2 (DictGer.verlaengern_V) ;
|
|
lens_N = DictGer.linse_N ;
|
|
lentil_N = DictGer.linse_N ;
|
|
leopard_N = DictGer.leopard_N ;
|
|
lessee_N = DictGer.paechter_N ;
|
|
lesson_N = DictGer.lehre_N ;
|
|
lessor_N = DictGer.vermieter_N ;
|
|
let_V = DictGer.lassen_3_V ;
|
|
let_V2 = P.dirV2 (DictGer.lassen_3_V) ;
|
|
lethal_A = DictGer.toedlich_A ;
|
|
letter_N = DictGer.brief_N ;
|
|
lettuce_N = DictGer.kopfsalat_N ;
|
|
leukaemia_N = DictGer.leukaemie_N ;
|
|
level_A = DictGer.eben_A ;
|
|
lever_N = DictGer.hebel_N ;
|
|
leverage_N = DictGer.einfluss_N ;
|
|
levitate_V = DictGer.schweben_V ;
|
|
levitate_V2 = P.dirV2 (DictGer.schweben_V) ;
|
|
levitation_N = DictGer.levitation_N ;
|
|
lewd_A = DictGer.lasziv_A ;
|
|
lexical_A = DictGer.lexikalisch_A ;
|
|
liability_N = DictGer.schuld_N ;
|
|
liable_A = DictGer.fehlbar_A ;
|
|
liaison_N = DictGer.liaison_N ;
|
|
liar_N = DictGer.luegner_N ;
|
|
libel_N = DictGer.verleumdung_N ;
|
|
liberate_V2 = P.dirV2 (DictGer.befreien_V) ;
|
|
liberation_N = DictGer.befreiung_N ;
|
|
liberty_N = DictGer.freiheit_N ;
|
|
libidinous_A = DictGer.luestern_A ;
|
|
librarian_N = DictGer.bibliothekar_N ;
|
|
library_N = DictGer.bibliothek_N ;
|
|
licentious_A = DictGer.ausschweifend_A ;
|
|
lichen_N = DictGer.flechte_N ;
|
|
lick_V = DictGer.besiegen_V ;
|
|
lick_V2 = P.dirV2 (DictGer.besiegen_V) ;
|
|
lid_N = DictGer.deckel_N ;
|
|
lie_V = LexiconGer.lie_V ;
|
|
life_N = DictGer.leben_N ;
|
|
lifeboat_N = DictGer.rettungsboot_N ;
|
|
lifeguard_N = DictGer.rettungsschwimmer_N ;
|
|
lifeless_A = DictGer.leblos_A ;
|
|
lifetime_N = DictGer.ewigkeit_N ;
|
|
lift_N = DictGer.auftrieb_N ;
|
|
ligature_N = DictGer.ligatur_N ;
|
|
light_V = DictGer.beleuchten_V ;
|
|
light_V2 = P.dirV2 (DictGer.beleuchten_V) ;
|
|
lighten_V = DictGer.erleichtern_V ;
|
|
lighten_V2 = P.dirV2 (DictGer.erleichtern_V) ;
|
|
lighthouse_N = DictGer.leuchtturm_N ;
|
|
lightning_N = DictGer.blitz_N ;
|
|
lignite_N = DictGer.braunkohle_N ;
|
|
like_V2 = LexiconGer.like_V2 ;
|
|
likelihood_N = DictGer.wahrscheinlichkeit_N ;
|
|
likely_A = DictGer.glaubhaft_A ;
|
|
liken_V2 = P.dirV2 (DictGer.vergleichen_V) ;
|
|
lilac_N = DictGer.flieder_N ;
|
|
lily_N = DictGer.lilie_N ;
|
|
lime_N = DictGer.limone_N ;
|
|
limelight_N = DictGer.rampenlicht_N ;
|
|
limestone_N = DictGer.kalkstein_N ;
|
|
limit_N = DictGer.grenze_N ;
|
|
limp_V = DictGer.hinken_V ;
|
|
line_N = DictGer.kante_N ;
|
|
linen_N = DictGer.leinen_N ;
|
|
lingo_N = DictGer.fachjargon_N ;
|
|
linguist_N = DictGer.linguist_N ;
|
|
linguistic_A = DictGer.linguistisch_A ;
|
|
linguistics_N = DictGer.sprachwissenschaft_N ;
|
|
link_N = DictGer.link_N ;
|
|
linnet_N = DictGer.haenfling_N ;
|
|
linseed_N = DictGer.leinsamen_N ;
|
|
lint_N = DictGer.fluse_N ;
|
|
lion_N = DictGer.leu_N ;
|
|
lioness_N = DictGer.loewin_N ;
|
|
lip_N = DictGer.lefze_N ;
|
|
lipstick_N = DictGer.lippenstift_N ;
|
|
liquefy_V = DictGer.verfluessigen_V ;
|
|
liquefy_V2 = P.dirV2 (DictGer.verfluessigen_V) ;
|
|
liqueur_N = DictGer.likoer_N ;
|
|
liquid_N = DictGer.fluessigkeit_N ;
|
|
liquorice_N = DictGer.lakritze_N ;
|
|
list_N = DictGer.kraengung_N ;
|
|
listen_V = DictGer.hoeren_7_V ;
|
|
listless_A = DictGer.lasch_A ;
|
|
literacy_N = DictGer.bildung_N ;
|
|
literal_A = DictGer.buchstaeblich_A ;
|
|
literary_A = DictGer.literarisch_A ;
|
|
literature_N = DictGer.literatur_N ;
|
|
litigate_V = DictGer.prozessieren_V ;
|
|
litigate_V2 = P.dirV2 (DictGer.prozessieren_V) ;
|
|
litigious_A = DictGer.streitsuechtig_A ;
|
|
litotes_N = DictGer.litotes_N ;
|
|
litter_N = DictGer.abfall_N ;
|
|
little_A = DictGer.jung_A ;
|
|
liturgical_A = DictGer.liturgisch_A ;
|
|
liturgy_N = DictGer.liturgie_N ;
|
|
live_V = LexiconGer.live_V ;
|
|
live_V2 = P.dirV2 (DictGer.leben_V) ;
|
|
lively_A = DictGer.lebhaft_A ;
|
|
liver_N = LexiconGer.liver_N ;
|
|
liverwurst_N = DictGer.leberwurst_N ;
|
|
lizard_N = DictGer.eidechse_N ;
|
|
llama_N = DictGer.lama_N ;
|
|
loaf_N = DictGer.laib_N ;
|
|
loafer_N = DictGer.faulpelz_N ;
|
|
loam_N = DictGer.lehm_N ;
|
|
loan_N = DictGer.anleihe_N ;
|
|
loanword_N = DictGer.lehnwort_N ;
|
|
loath_A = DictGer.abgeneigt_A ;
|
|
loathe_V2 = P.dirV2 (DictGer.verabscheuen_V) ;
|
|
loathsome_A = DictGer.abscheulich_A ;
|
|
lobby_N = DictGer.foyer_N ;
|
|
local_A = DictGer.lokal_A ;
|
|
localization_N = DictGer.lokalisierung_N ;
|
|
location_N = DictGer.ort_N ;
|
|
lock_N = DictGer.locke_N ;
|
|
locker_N = DictGer.spind_N ;
|
|
locksmith_N = DictGer.schlosser_N ;
|
|
locomotive_N = DictGer.lokomotive_N ;
|
|
locust_N = DictGer.heuschrecke_N ;
|
|
lode_N = DictGer.ader_N ;
|
|
lodge_N = DictGer.loge_N ;
|
|
loess_N = DictGer.loess_N ;
|
|
loft_N = DictGer.dachboden_N ;
|
|
lofty_A = DictGer.ambitioniert_A ;
|
|
log_N = DictGer.log_N ;
|
|
logarithm_N = DictGer.logarithmus_N ;
|
|
logbook_N = DictGer.logbuch_N ;
|
|
logic_N = DictGer.logik_N ;
|
|
logical_A = DictGer.logisch_A ;
|
|
logistics_N = DictGer.logistik_N ;
|
|
loin_N = DictGer.lende_N ;
|
|
loincloth_N = DictGer.lendenschurz_N ;
|
|
loll_V = DictGer.raekeln_V ;
|
|
loll_V2 = P.dirV2 (DictGer.raekeln_V) ;
|
|
lollipop_N = DictGer.dauerlutscher_N ;
|
|
lone_A = DictGer.einzeln_A ;
|
|
loneliness_N = DictGer.einsamkeit_N ;
|
|
lonely_A = DictGer.einsam_A ;
|
|
lonesome_A = DictGer.einsam_A ;
|
|
long_A = LexiconGer.long_A ;
|
|
look_V = DictGer.blicken_V ;
|
|
look_V2 = P.dirV2 (DictGer.blicken_V) ;
|
|
loom_N = DictGer.webstuhl_N ;
|
|
loon_N = DictGer.seetaucher_N ;
|
|
loop_N = DictGer.schleife_N ;
|
|
loophole_N = DictGer.ausflucht_N ;
|
|
loose_V2 = P.dirV2 (DictGer.loesen_5_V) ;
|
|
loosen_V = DictGer.loesen_5_V ;
|
|
loosen_V2 = P.dirV2 (DictGer.loesen_5_V) ;
|
|
looter_N = DictGer.pluenderer_N ;
|
|
lopsided_A = DictGer.einseitig_A ;
|
|
loquacious_A = DictGer.geschwaetzig_A ;
|
|
loquacity_N = DictGer.geschwaetzigkeit_N ;
|
|
lord_N = DictGer.herr_N ;
|
|
lorry_N = DictGer.lastkraftwagen_N ;
|
|
lose_V = DictGer.verlieren_V ;
|
|
lose_V2 = LexiconGer.lose_V2 ;
|
|
loser_N = DictGer.verlierer_N ;
|
|
loss_N = DictGer.niederlage_N ;
|
|
lot_N = DictGer.number_N ;
|
|
lotion_N = DictGer.lotion_N ;
|
|
lottery_N = DictGer.lotterie_N ;
|
|
loud_A = DictGer.grell_A ;
|
|
loudspeaker_N = DictGer.lautsprecher_N ;
|
|
lounge_N = DictGer.lounge_N ;
|
|
louse_N = LexiconGer.louse_N ;
|
|
lousy_A = DictGer.lausig_A ;
|
|
love_N = LexiconGer.love_N ;
|
|
love_V2 = LexiconGer.love_V2 ;
|
|
loveless_A = DictGer.herzlos_A ;
|
|
lovely_A = DictGer.lieblich_A ;
|
|
lover_N = DictGer.liebhaber_N ;
|
|
low_A = DictGer.niedrig_A ;
|
|
loyal_A = DictGer.loyal_A ;
|
|
loyalty_N = DictGer.loyalitaet_N ;
|
|
lozenge_N = DictGer.raute_N ;
|
|
lubricant_N = DictGer.gleitmittel_N ;
|
|
lubricate_V2 = P.dirV2 (DictGer.schmieren_8_V) ;
|
|
lucky_A = DictGer.gluecklich_A ;
|
|
ludicrous_A = DictGer.aberwitzig_A ;
|
|
lugubrious_A = DictGer.duester_A ;
|
|
lukewarm_A = DictGer.lauwarm_A ;
|
|
lullaby_N = DictGer.schlaflied_N ;
|
|
lumber_N = DictGer.bauholz_N ;
|
|
lumberjack_N = DictGer.holzfaeller_N ;
|
|
luminosity_N = DictGer.helligkeit_N ;
|
|
lump_N = DictGer.kloss_N ;
|
|
lunar_A = DictGer.lunar_A ;
|
|
lunch_N = DictGer.mittagessen_N ;
|
|
lung_N = DictGer.lunge_N ;
|
|
lurch_N = DictGer.ruck_N ;
|
|
lure_N = DictGer.koeder_N ;
|
|
lurid_A = DictGer.grell_A ;
|
|
lurk_V = DictGer.lauern_V ;
|
|
lust_N = DictGer.lust_N ;
|
|
lute_N = DictGer.laute_N ;
|
|
luxuriant_A = DictGer.luxurioes_A ;
|
|
luxurious_A = DictGer.luxurioes_A ;
|
|
lychee_N = DictGer.litschi_N ;
|
|
lye_N = DictGer.lauge_N ;
|
|
lymph_N = DictGer.lymphe_N ;
|
|
lynch_V2 = P.dirV2 (DictGer.lynchen_V) ;
|
|
lynx_N = DictGer.luchs_N ;
|
|
lyre_N = DictGer.leier_N ;
|
|
ma_N = DictGer.mutter_N ;
|
|
macabre_A = DictGer.makaber_A ;
|
|
machete_N = DictGer.machete_N ;
|
|
machination_N = DictGer.machenschaft_N ;
|
|
machine_N = DictGer.maschine_N ;
|
|
mackerel_N = DictGer.makrele_N ;
|
|
mad_A = DictGer.boese_A ;
|
|
madam_N = DictGer.frau_N ;
|
|
madwoman_N = DictGer.irre_N ;
|
|
mafia_N = DictGer.mafia_N ;
|
|
magazine_N = DictGer.magazin_N ;
|
|
maggot_N = DictGer.made_N ;
|
|
magic_N = DictGer.zauber_N ;
|
|
magician_N = DictGer.zauberer_N ;
|
|
magnanimous_A = DictGer.grossmuetig_A ;
|
|
magnesium_N = DictGer.magnesium_N ;
|
|
magnetic_A = DictGer.magnetisch_A ;
|
|
magnification_N = DictGer.vergroesserung_N ;
|
|
magnificent_A = DictGer.ausgezeichnet_A ;
|
|
magnify_V2 = P.dirV2 (DictGer.vergroessern_V) ;
|
|
magnolia_N = DictGer.magnolie_N ;
|
|
magpie_N = DictGer.elster_N ;
|
|
maid_N = DictGer.dienstmaedchen_N ;
|
|
maiden_N = DictGer.jungfrau_N ;
|
|
mailbox_N = DictGer.briefkasten_N ;
|
|
mailman_N = DictGer.postbote_N ;
|
|
maim_V2 = P.dirV2 (DictGer.verstuemmeln_V) ;
|
|
main_A = DictGer.hauptsaechlich_A ;
|
|
mainland_N = DictGer.festland_N ;
|
|
maintain_V = DictGer.unterhalten_V ;
|
|
maintain_V2 = P.dirV2 (DictGer.unterhalten_V) ;
|
|
maintenance_N = DictGer.wartung_N ;
|
|
maize_N = DictGer.mais_N ;
|
|
majesty_N = DictGer.majestaet_N ;
|
|
major_N = DictGer.major_N ;
|
|
majority_N = DictGer.mehrheit_N ;
|
|
make_V = DictGer.bauen_0_V ;
|
|
make_V2 = P.dirV2 (DictGer.bauen_0_V) ;
|
|
maker_N = DictGer.fabrikant_N ;
|
|
male_A = DictGer.maennlich_A ;
|
|
malefactor_N = DictGer.uebeltaeter_N ;
|
|
malfeasance_N = DictGer.sabotage_N ;
|
|
malicious_A = DictGer.boshaft_A ;
|
|
malign_A = DictGer.unheilvoll_A ;
|
|
malignant_A = DictGer.boesartig_A ;
|
|
mallard_N = DictGer.stockente_N ;
|
|
maltreat_V2 = P.dirV2 (DictGer.misshandeln_V) ;
|
|
mammal_N = DictGer.saeugetier_N ;
|
|
man_N = LexiconGer.man_N ;
|
|
manage_V = DictGer.leiten_4_V ;
|
|
manage_V2 = P.dirV2 (DictGer.leiten_4_V) ;
|
|
management_N = DictGer.fuehrung_N ;
|
|
manager_N = DictGer.direktor_N ;
|
|
mandarin_N = DictGer.mandarin_N ;
|
|
mandate_N = DictGer.mandat_N ;
|
|
mandolin_N = DictGer.mandoline_N ;
|
|
mandrake_N = DictGer.alraune_N ;
|
|
mane_N = DictGer.maehne_N ;
|
|
manger_N = DictGer.krippe_N ;
|
|
mangle_V2 = P.dirV2 (DictGer.mangeln_V) ;
|
|
mangy_A = DictGer.raeudig_A ;
|
|
mania_N = DictGer.manie_N ;
|
|
manifestation_N = DictGer.erscheinung_N ;
|
|
manifesto_N = DictGer.manifest_N ;
|
|
manifold_N = DictGer.mannigfaltigkeit_N ;
|
|
manipulate_V2 = P.dirV2 (DictGer.manipulieren_V) ;
|
|
manipulation_N = DictGer.manipulation_N ;
|
|
manipulative_A = DictGer.manipulativ_A ;
|
|
manly_A = DictGer.maennlich_A ;
|
|
mannequin_N = DictGer.model_N ;
|
|
manner_N = DictGer.manier_N ;
|
|
mantis_N = DictGer.gottesanbeterin_N ;
|
|
mantle_N = DictGer.huelle_N ;
|
|
manual_N = DictGer.handbuch_N ;
|
|
manufacture_N = DictGer.produkt_N ;
|
|
manufacturer_N = DictGer.hersteller_N ;
|
|
map_N = DictGer.abbildung_N ;
|
|
maple_N = DictGer.ahorn_N ;
|
|
marabou_N = DictGer.marabu_N ;
|
|
marathon_N = DictGer.marathon_N ;
|
|
maraud_V = DictGer.marodieren_V ;
|
|
marble_N = DictGer.marmor_N ;
|
|
march_N = DictGer.fortgang_N ;
|
|
marchioness_N = DictGer.marquise_N ;
|
|
mare_N = DictGer.maehre_N ;
|
|
marigold_N = DictGer.ringelblume_N ;
|
|
marinade_N = DictGer.marinade_N ;
|
|
marinate_V2 = P.dirV2 (DictGer.marinieren_V) ;
|
|
marionette_N = DictGer.marionette_N ;
|
|
marital_A = DictGer.ehelich_A ;
|
|
marjoram_N = DictGer.majoran_N ;
|
|
mark_N = DictGer.note_N ;
|
|
market_N = DictGer.markt_N ;
|
|
marksman_N = DictGer.scharfschuetze_N ;
|
|
marmalade_N = DictGer.marmelade_N ;
|
|
marmot_N = DictGer.murmeltier_N ;
|
|
marquess_N = DictGer.marquis_N ;
|
|
marriage_N = DictGer.ehe_N ;
|
|
married_A = DictGer.verheiratet_A ;
|
|
marry_V = DictGer.heiraten_V ;
|
|
marry_V2 = P.dirV2 (DictGer.heiraten_V) ;
|
|
marsh_N = DictGer.marsch_N ;
|
|
marshal_N = DictGer.feldmarschall_N ;
|
|
marshmallow_N = DictGer.eibisch_N ;
|
|
marsupial_N = DictGer.beuteltier_N ;
|
|
marten_N = DictGer.marder_N ;
|
|
martyr_N = DictGer.maertyrer_N ;
|
|
marvelous_A = DictGer.wunderbar_A ;
|
|
marzipan_N = DictGer.marzipan_N ;
|
|
masculine_A = DictGer.maskulin_A ;
|
|
mask_N = DictGer.maske_N ;
|
|
masochistic_A = DictGer.masochistisch_A ;
|
|
mason_N = DictGer.maurer_N ;
|
|
mass_N = DictGer.masse_N ;
|
|
massacre_N = DictGer.massaker_N ;
|
|
massage_N = DictGer.massage_N ;
|
|
masseur_N = DictGer.masseur_N ;
|
|
masseuse_N = DictGer.masseurin_N ;
|
|
massif_N = DictGer.massiv_N ;
|
|
massive_A = DictGer.massiv_A ;
|
|
master_N = DictGer.meister_N ;
|
|
masterpiece_N = DictGer.meisterwerk_N ;
|
|
mastery_N = DictGer.meisterschaft__N ;
|
|
masticate_V2 = P.dirV2 (DictGer.kauen_V) ;
|
|
masturbate_V = DictGer.masturbieren_V ;
|
|
masturbate_V2 = P.dirV2 (DictGer.masturbieren_V) ;
|
|
masturbation_N = DictGer.masturbation_N ;
|
|
mat_N = DictGer.matte_N ;
|
|
match_N = DictGer.spiel_N ;
|
|
matchbox_N = DictGer.streichholzschachtel_N ;
|
|
material_A = DictGer.materiell_A ;
|
|
mathematical_A = DictGer.mathematisch_A ;
|
|
mathematician_N = DictGer.mathematiker_N ;
|
|
matinee_N = DictGer.matinee_N ;
|
|
matrimony_N = DictGer.ehe_N ;
|
|
matrix_N = DictGer.matrix_N ;
|
|
matter_N = DictGer.angelegenheit_N ;
|
|
mattress_N = DictGer.matratze_N ;
|
|
mature_A = DictGer.reif_A ;
|
|
matutinal_A = DictGer.morgendlich_A ;
|
|
mausoleum_N = DictGer.mausoleum_N ;
|
|
maxim_N = DictGer.maxime_N ;
|
|
maximal_A = DictGer.maximal_A ;
|
|
maximize_V2 = P.dirV2 (DictGer.maximieren_V) ;
|
|
maximum_N = DictGer.maximum_N ;
|
|
mayfly_N = DictGer.eintagsfliege_N ;
|
|
mayonnaise_N = DictGer.majonaese_N ;
|
|
mayor_N = DictGer.buergermeister_N ;
|
|
maypole_N = DictGer.maibaum_N ;
|
|
maze_N = DictGer.irrgarten_N ;
|
|
meadow_N = DictGer.weide_N ;
|
|
meal_N = DictGer.mehl_N ;
|
|
mean_V = DictGer.beabsichtigen_V ;
|
|
mean_V2 = P.dirV2 (DictGer.beabsichtigen_V) ;
|
|
meaning_N = DictGer.bedeutung_N ;
|
|
meaningful_A = DictGer.bedeutend_A ;
|
|
meaningless_A = DictGer.bedeutungslos_A ;
|
|
measurable_A = DictGer.messbar_A ;
|
|
measure_N = DictGer.mass_N ;
|
|
measurement_N = DictGer.mass_N ;
|
|
meat_N = LexiconGer.meat_N ;
|
|
meatball_N = DictGer.frikadelle_N ;
|
|
mechanic_N = DictGer.mechaniker_N ;
|
|
mechanical_A = DictGer.mechanisch_A ;
|
|
mechanics_N = DictGer.mechanik_N ;
|
|
mechanism_N = DictGer.mechanismus_N ;
|
|
medal_N = DictGer.medaille_N ;
|
|
median_N = DictGer.median_N ;
|
|
mediate_V = DictGer.schlichten_V ;
|
|
mediate_V2 = P.dirV2 (DictGer.schlichten_V) ;
|
|
medical_A = DictGer.medizinisch_A ;
|
|
medicate_V2 = P.dirV2 (DictGer.verschreiben_V) ;
|
|
medication_N = DictGer.medikation_N ;
|
|
medicine_N = DictGer.arznei_N ;
|
|
medieval_A = DictGer.mittelalterlich_A ;
|
|
mediocre_A = DictGer.mittelmaessig_A ;
|
|
meditation_N = DictGer.meditation_N ;
|
|
medium_N = DictGer.medium_N ;
|
|
medlar_N = DictGer.mispel_N ;
|
|
meet_V = DictGer.begegnen_V ;
|
|
meet_V2 = P.dirV2 (DictGer.begegnen_V) ;
|
|
meiosis_N = DictGer.meiose_N ;
|
|
melancholic_A = DictGer.melancholisch_A ;
|
|
melancholy_A = DictGer.melancholisch_A ;
|
|
melioration_N = DictGer.melioration_N ;
|
|
melody_N = DictGer.melodie_N ;
|
|
melon_N = DictGer.melone_N ;
|
|
member_N = DictGer.glied_N ;
|
|
membership_N = DictGer.mitgliedschaft_N ;
|
|
membrane_N = DictGer.membrane_N ;
|
|
memento_N = DictGer.andenken_N ;
|
|
memo_N = DictGer.memo_N ;
|
|
memorandum_N = DictGer.memorandum_N ;
|
|
memory_N = DictGer.erinnerung_N ;
|
|
mendacious_A = DictGer.luegnerisch_A ;
|
|
menial_A = DictGer.niedrig_A ;
|
|
menopause_N = DictGer.menopause_N ;
|
|
menstruation_N = DictGer.menstruation_N ;
|
|
mental_A = DictGer.geistig_A ;
|
|
mentality_N = DictGer.mentalitaet_N ;
|
|
mention_N = DictGer.erwaehnung_N ;
|
|
mentor_N = DictGer.mentor_N ;
|
|
menu_N = DictGer.menue_N ;
|
|
merchant_N = DictGer.kaufmann_N ;
|
|
merciful_A = DictGer.barmherzig_A ;
|
|
mercy_N = DictGer.gnade_N ;
|
|
merger_N = DictGer.fusion_N ;
|
|
meridian_N = DictGer.meridian_N ;
|
|
meringue_N = DictGer.baiser_N ;
|
|
merit_N = DictGer.verdienst_N ;
|
|
mermaid_N = DictGer.meerjungfrau_N ;
|
|
merry_A = DictGer.froehlich_A ;
|
|
mess_N = DictGer.durcheinander_N ;
|
|
message_N = DictGer.botschaft_N ;
|
|
messenger_N = DictGer.bote_N ;
|
|
messiah_N = DictGer.messias_N ;
|
|
messy_A = DictGer.chaotisch_A ;
|
|
metabolism_N = DictGer.metabolismus_N ;
|
|
metal_N = DictGer.metall_N ;
|
|
metamorphosis_N = DictGer.metamorphose_N ;
|
|
metaphor_N = DictGer.metapher_N ;
|
|
metaphorical_A = DictGer.metaphorisch_A ;
|
|
metaphysical_A = DictGer.metaphysisch_A ;
|
|
meteorite_N = DictGer.meteorit_N ;
|
|
meteorology_N = DictGer.wettervorhersage_N ;
|
|
meter_N = DictGer.messgeraet_N ;
|
|
method_N = DictGer.methode_N ;
|
|
methodological_A = DictGer.methodologisch_A ;
|
|
methodology_N = DictGer.methodologie__N ;
|
|
metier_N = DictGer.metier_N ;
|
|
metric_A = DictGer.metrisch_A ;
|
|
metro_N = DictGer.untergrundbahn_N ;
|
|
metronome_N = DictGer.metronom_N ;
|
|
microbe_N = DictGer.mikrobe_N ;
|
|
micrometer_N = DictGer.mikrometer_N ;
|
|
microphone_N = DictGer.mikrofon_N ;
|
|
microscope_N = DictGer.mikroskop_N ;
|
|
microscopic_A = DictGer.mikroskopisch_A ;
|
|
microwave_N = DictGer.mikrowelle_N ;
|
|
middle_N = DictGer.mitte__N ;
|
|
midge_N = DictGer.muecke_N ;
|
|
midget_N = DictGer.zwerg_N ;
|
|
midnight_N = DictGer.mitternacht_N ;
|
|
midwife_N = DictGer.geburtshelfer_N ;
|
|
might_N = DictGer.kraft_N ;
|
|
migraine_N = DictGer.migraene_N ;
|
|
migrant_N = DictGer.migrant_N ;
|
|
migration_N = DictGer.migration_N ;
|
|
mild_A = DictGer.mild_A ;
|
|
mildew_N = DictGer.schimmel_N ;
|
|
mile_N = DictGer.meile_N ;
|
|
milestone_N = DictGer.meilenstein_N ;
|
|
milieu_N = DictGer.milieu_N ;
|
|
militia_N = DictGer.miliz_N ;
|
|
milk_N = LexiconGer.milk_N ;
|
|
milkmaid_N = DictGer.melkerin_N ;
|
|
milkshake_N = DictGer.milchmixgetraenk_N ;
|
|
mill_N = DictGer.muehle_N ;
|
|
millennium_N = DictGer.jahrtausend_N ;
|
|
millet_N = DictGer.hirse_N ;
|
|
milliard_N = DictGer.milliarde_N ;
|
|
millimetre_N = DictGer.millimeter_N ;
|
|
millionaire_N = DictGer.millionaer_N ;
|
|
millionth_A = DictGer.millionstel_A ;
|
|
millipede_N = DictGer.tausendfuessler_N ;
|
|
millstone_N = DictGer.muehlstein_N ;
|
|
milt_N = DictGer.milk_N ;
|
|
mincer_N = DictGer.fleischwolf_N ;
|
|
mind_N = DictGer.meinung_N ;
|
|
minder_N = DictGer.leibwaechter_N ;
|
|
mine_N = DictGer.bergwerk_N ;
|
|
minefield_N = DictGer.minenfeld_N ;
|
|
miner_N = DictGer.bergarbeiter_N ;
|
|
mingle_V = DictGer.vermengen_V ;
|
|
mingle_V2 = P.dirV2 (DictGer.vermengen_V) ;
|
|
minimal_A = DictGer.minimal_A ;
|
|
minimize_V2 = P.dirV2 (DictGer.minimieren_V) ;
|
|
minimum_N = DictGer.minimum_N ;
|
|
minister_N = DictGer.minister_N ;
|
|
ministry_N = DictGer.ministerium_N ;
|
|
mink_N = DictGer.nerz_N ;
|
|
minor_A = DictGer.gering_A ;
|
|
minority_N = DictGer.minderheit_N ;
|
|
mint_V2 = P.dirV2 (DictGer.praegen_V) ;
|
|
minute_N = DictGer.minute_N ;
|
|
miracle_N = DictGer.wunder_N ;
|
|
mirage_N = DictGer.luftspiegelung_N ;
|
|
mire_N = DictGer.schlamm_N ;
|
|
mirror_N = DictGer.kopie_N ;
|
|
mirth_N = DictGer.belustigung_N ;
|
|
misanthrope_N = DictGer.misanthrop_N ;
|
|
miscarriage_N = DictGer.fehlgeburt_N ;
|
|
miscarry_V2 = P.dirV2 (DictGer.misslingen_V) ;
|
|
miscellaneous_A = DictGer.gemischt_A ;
|
|
mischief_N = DictGer.stoerenfried_N ;
|
|
mischievous_A = DictGer.dreist_A ;
|
|
miser_N = DictGer.geizhals_N ;
|
|
miserable_A = DictGer.erbaermlich_A ;
|
|
miserly_A = DictGer.geizig_A ;
|
|
misfortune_N = DictGer.pech_N ;
|
|
mishap_N = DictGer.missgeschick__N ;
|
|
mishmash_N = DictGer.mischmasch_N ;
|
|
misnomer_N = DictGer.unwort_N ;
|
|
misogynist_N = DictGer.misogyn_N ;
|
|
misplace_V2 = P.dirV2 (DictGer.verlegen_V) ;
|
|
miss_V = DictGer.vermissen_V ;
|
|
miss_V2 = P.dirV2 (DictGer.vermissen_V) ;
|
|
missile_N = DictGer.rakete_N ;
|
|
mission_N = DictGer.auftrag_N ;
|
|
missionary_N = DictGer.missionar_N ;
|
|
misspelling_N = DictGer.rechtschreibfehler_N ;
|
|
mist_N = DictGer.dunst_N ;
|
|
mistake_N = DictGer.fehler_N ;
|
|
mister_N = DictGer.herr_N ;
|
|
mistletoe_N = DictGer.mistel_N ;
|
|
mistreat_V2 = P.dirV2 (DictGer.misshandeln_V) ;
|
|
mistress_N = DictGer.maetresse_N ;
|
|
misunderstanding_N = DictGer.missverstaendnis_N ;
|
|
mite_N = DictGer.milbe_N ;
|
|
mitigation_N = DictGer.erleichterung_N ;
|
|
mix_V = DictGer.mischen_5_V ;
|
|
mix_V2 = P.dirV2 (DictGer.mischen_5_V) ;
|
|
mixer_N = DictGer.mixer_N ;
|
|
mixture_N = DictGer.mischung_N ;
|
|
mobile_A = DictGer.beweglich_A ;
|
|
modal_A = DictGer.modal_A ;
|
|
mode_N = DictGer.mode_N ;
|
|
model_N = DictGer.model_N ;
|
|
moderate_A = DictGer.moderat_A ;
|
|
moderator_N = DictGer.moderator_N ;
|
|
modest_A = DictGer.bescheiden_A ;
|
|
modification_N = DictGer.abaenderung_N ;
|
|
modifier_N = DictGer.bestimmung_N ;
|
|
modify_V2 = P.dirV2 (DictGer.modifizieren_V) ;
|
|
modular_A = DictGer.modular_A ;
|
|
module_N = DictGer.modul_N ;
|
|
mogul_N = DictGer.buckel_N ;
|
|
moist_A = DictGer.feucht_A ;
|
|
moisture_N = DictGer.feuchtigkeit_N ;
|
|
molar_N = DictGer.backenzahn_N ;
|
|
molasses_N = DictGer.melasse_N ;
|
|
mole_N = DictGer.mal_N ;
|
|
molecular_A = DictGer.molekular_A ;
|
|
molecule_N = DictGer.molekuel_N ;
|
|
molehill_N = DictGer.maulwurfshaufen_N ;
|
|
molest_V2 = P.dirV2 (DictGer.belaestigen_V) ;
|
|
mollusc_N = DictGer.molluske_N ;
|
|
moment_N = DictGer.augenblick_N ;
|
|
momentous_A = DictGer.bedeutsam_A ;
|
|
momentum_N = DictGer.impuls_N ;
|
|
monarch_N = DictGer.fuerst_N ;
|
|
monarchy_N = DictGer.monarchie_N ;
|
|
monastery_N = DictGer.kloster_N ;
|
|
monday_N = DictGer.montag_N ;
|
|
money_N = DictGer.geld_N ;
|
|
monitor_N = DictGer.bildschirm_N ;
|
|
monk_N = DictGer.moench_N ;
|
|
monkey_N = DictGer.affe_N ;
|
|
monogram_N = DictGer.monogramm_N ;
|
|
monologue_N = DictGer.monolog_N ;
|
|
monopoly_N = DictGer.monopol_N ;
|
|
monosyllabic_A = DictGer.einsilbig_A ;
|
|
monotheist_N = DictGer.monotheist_N ;
|
|
monotheistic_A = DictGer.monotheistisch_A ;
|
|
monotonous_A = DictGer.eintoenig_A ;
|
|
monotony_N = DictGer.eintoenigkeit_N ;
|
|
monsoon_N = DictGer.monsun_N ;
|
|
monster_N = DictGer.monster_N ;
|
|
monstrance_N = DictGer.monstranz_N ;
|
|
monstrous_A = DictGer.ungeheuerlich_A ;
|
|
montage_N = DictGer.montage_N ;
|
|
month_N = DictGer.monat_N ;
|
|
monthly_A = DictGer.monatlich_A ;
|
|
mooch_V = DictGer.schnorren_V ;
|
|
mood_N = DictGer.gemuet_N ;
|
|
moody_A = DictGer.launisch_A ;
|
|
moon_N = LexiconGer.moon_N ;
|
|
moonstone_N = DictGer.mondstein_N ;
|
|
moor_N = DictGer.moor_N ;
|
|
moose_N = DictGer.elch_N ;
|
|
moot_A = DictGer.irrelevant_A ;
|
|
moraine_N = DictGer.moraene_N ;
|
|
moral_A = DictGer.moralisch_A ;
|
|
morale_N = DictGer.moral_N ;
|
|
morality_N = DictGer.moral_N ;
|
|
moratorium_N = DictGer.moratorium_N ;
|
|
morbid_A = DictGer.krankhaft_A ;
|
|
mordant_A = DictGer.beissend_A ;
|
|
morello_N = DictGer.schattenmorelle_N ;
|
|
morning_N = DictGer.morgen_N ;
|
|
moron_N = DictGer.schwachkopf__N ;
|
|
morpheme_N = DictGer.morphem_N ;
|
|
morphine_N = DictGer.morphin_N ;
|
|
morphology_N = DictGer.wortbildung_N ;
|
|
morrow_N = DictGer.morgen_N ;
|
|
morsel_N = DictGer.happen_N ;
|
|
mortal_A = DictGer.sterblich_A ;
|
|
mortality_N = DictGer.sterblichkeit_N ;
|
|
mortar_N = DictGer.moerser_N ;
|
|
mortgage_N = DictGer.hypothek_N ;
|
|
mosaic_N = DictGer.collage_N ;
|
|
mosque_N = DictGer.moschee_N ;
|
|
mosquito_N = DictGer.moskito_N ;
|
|
motel_N = DictGer.motel_N ;
|
|
moth_N = DictGer.motte_N ;
|
|
mother_N = DictGer.mutter_N ;
|
|
motif_N = DictGer.motiv_N ;
|
|
motion_N = DictGer.bewegung_N ;
|
|
motivate_V2 = P.dirV2 (DictGer.motivieren_V) ;
|
|
motivation_N = DictGer.motivation_N ;
|
|
motive_N = DictGer.motiv_N ;
|
|
motor_N = DictGer.antrieb_N ;
|
|
motorboat_N = DictGer.motorboot_N ;
|
|
motorcar_N = DictGer.auto_N ;
|
|
motorcycle_N = DictGer.motorrad_N ;
|
|
motorway_N = DictGer.autobahn_N ;
|
|
moult_N = DictGer.mauser_N ;
|
|
mount_N = DictGer.berg_N ;
|
|
mountain_N = LexiconGer.mountain_N ;
|
|
mountaineer_N = DictGer.bergsteiger_N ;
|
|
mountainous_A = DictGer.bergig_A ;
|
|
mourn_V = DictGer.trauern_V ;
|
|
mourn_V2 = P.dirV2 (DictGer.trauern_V) ;
|
|
mouse_N = DictGer.maus__N ;
|
|
mousetrap_N = DictGer.mausefalle_N ;
|
|
moustache_N = DictGer.schnurrbart_N ;
|
|
mouth_N = LexiconGer.mouth_N ;
|
|
movable_A = DictGer.beweglich_A ;
|
|
move_V = DictGer.bewegen_V ;
|
|
move_V2 = P.dirV2 (DictGer.bewegen_V) ;
|
|
movement_N = DictGer.bewegung_N ;
|
|
movie_N = DictGer.film_N ;
|
|
mow_V = DictGer.maehen_V ;
|
|
mow_V2 = P.dirV2 (DictGer.maehen_V) ;
|
|
mucky_A = DictGer.dreckig_A ;
|
|
mucus_N = DictGer.schleim_N ;
|
|
mud_N = DictGer.schlamm_N ;
|
|
muddle_V = DictGer.verwirren_V ;
|
|
muddle_V2 = P.dirV2 (DictGer.verwirren_V) ;
|
|
muesli_N = DictGer.muesli_N ;
|
|
muezzin_N = DictGer.muezzin_N ;
|
|
muff_N = DictGer.muff_N ;
|
|
muffin_N = DictGer.muffin_N ;
|
|
muffler_N = DictGer.schalldaempfer_N ;
|
|
mufti_N = DictGer.mufti_N ;
|
|
mug_N = DictGer.becher_N ;
|
|
muggy_A = DictGer.schwuel_A ;
|
|
mulberry_N = DictGer.maulbeere_N ;
|
|
mulch_N = DictGer.mulch_N ;
|
|
mull_V2 = P.dirV2 (DictGer.erwaegen_V) ;
|
|
mullein_N = DictGer.koenigskerze_N ;
|
|
mullet_N = DictGer.vokuhila_N ;
|
|
multilateral_A = DictGer.multilateral_A ;
|
|
multiplication_N = DictGer.multiplikation_N ;
|
|
multiply_V = DictGer.multiplizieren_V ;
|
|
multiply_V2 = P.dirV2 (DictGer.multiplizieren_V) ;
|
|
mum_N = DictGer.mama_N ;
|
|
mumble_V = DictGer.murmeln_V ;
|
|
mumble_V2 = P.dirV2 (DictGer.murmeln_V) ;
|
|
mummy_N = DictGer.mama_N ;
|
|
munch_V = DictGer.mampfen_V ;
|
|
munch_V2 = P.dirV2 (DictGer.mampfen_V) ;
|
|
mundane_A = DictGer.alltaeglich_A ;
|
|
municipal_A = DictGer.munizipal_A ;
|
|
municipality_N = DictGer.gemeinde_N ;
|
|
murder_N = DictGer.mord_N ;
|
|
murderer_N = DictGer.moerder_N ;
|
|
murderess_N = DictGer.moerderin_N ;
|
|
murky_A = DictGer.duester_A ;
|
|
muscatel_N = DictGer.muskateller_N ;
|
|
muscle_N = DictGer.muskel_N ;
|
|
muscular_A = DictGer.muskulaer_A ;
|
|
muse_N = DictGer.muse_N ;
|
|
museum_N = DictGer.museum_N ;
|
|
mushroom_N = DictGer.pilz_N ;
|
|
music_N = LexiconGer.music_N ;
|
|
musician_N = DictGer.musikant_N ;
|
|
musket_N = DictGer.muskete_N ;
|
|
musketeer_N = DictGer.musketier_N ;
|
|
muskrat_N = DictGer.bisamratte_N ;
|
|
mussel_N = DictGer.miesmuschel_N ;
|
|
mustard_N = DictGer.senf_N ;
|
|
musty_A = DictGer.modrig_A ;
|
|
mutation_N = DictGer.mutation_N ;
|
|
mute_A = DictGer.stumm_A ;
|
|
mutilate_V = DictGer.verstuemmeln_V ;
|
|
mutilate_V2 = P.dirV2 (DictGer.verstuemmeln_V) ;
|
|
mutiny_N = DictGer.meuterei_N ;
|
|
mutt_N = DictGer.koeter_N ;
|
|
mutton_N = DictGer.hammel_N ;
|
|
mutual_A = DictGer.gegenseitig_A ;
|
|
muzzle_N = DictGer.maulkorb_N ;
|
|
myopic_A = DictGer.kurzsichtig_A ;
|
|
myriad_N = DictGer.unzahl_N ;
|
|
myrrh_N = DictGer.myrrhe_N ;
|
|
mysterious_A = DictGer.mysterioes_A ;
|
|
mystery_N = DictGer.geheimnis_N ;
|
|
mysticism_N = DictGer.mystizismus_N ;
|
|
myth_N = DictGer.mythos_N ;
|
|
mythology_N = DictGer.mythologie_N ;
|
|
nab_V2 = P.dirV2 (DictGer.schnappen_V) ;
|
|
nagger_N = DictGer.noergler_N ;
|
|
nail_N = DictGer.nagel_N ;
|
|
nakedness_N = DictGer.nacktheit_N ;
|
|
name_N = LexiconGer.name_N ;
|
|
nameless_A = DictGer.namenlos_A ;
|
|
namesake_N = DictGer.namensvetter_N ;
|
|
nap_N = DictGer.nickerchen_N ;
|
|
nape_N = DictGer.genick_N ;
|
|
napkin_N = DictGer.serviette_N ;
|
|
nappy_N = DictGer.windel_N ;
|
|
narcissism_N = DictGer.narzissmus_N ;
|
|
narrate_V2 = P.dirV2 (DictGer.erzaehlen_V) ;
|
|
narration_N = DictGer.erzaehlung_N ;
|
|
narrow_A = LexiconGer.narrow_A ;
|
|
narwhal_N = DictGer.narwal_N ;
|
|
nasal_A = DictGer.nasal_A ;
|
|
nasty_A = DictGer.boshaft_A ;
|
|
nation_N = DictGer.nation_N ;
|
|
nationalist_A = DictGer.nationalistisch_A ;
|
|
nationality_N = DictGer.nationalitaet_N ;
|
|
native_A = DictGer.einheimisch_A ;
|
|
natty_A = DictGer.nett_A ;
|
|
natural_A = DictGer.natuerlich_A ;
|
|
naturalist_N = DictGer.naturalist_N ;
|
|
naturalistic_A = DictGer.naturalistisch_A ;
|
|
nature_N = DictGer.natur_N ;
|
|
naughty_A = DictGer.dreist_A ;
|
|
nausea_N = DictGer.ekel_N ;
|
|
nave_N = DictGer.schiff_N ;
|
|
navel_N = DictGer.bauchnabel_N ;
|
|
navy_N = DictGer.marine_N ;
|
|
near_A = LexiconGer.near_A ;
|
|
nearby_A = DictGer.nah_A ;
|
|
nebula_N = DictGer.nebel_N ;
|
|
necessary_A = DictGer.notwendig_A ;
|
|
neck_N = LexiconGer.neck_N ;
|
|
neckerchief_N = DictGer.halstuch_N ;
|
|
necklace_N = DictGer.halskette_N ;
|
|
necktie_N = DictGer.krawatte_N ;
|
|
nectar_N = DictGer.nektar_N ;
|
|
nectarine_N = DictGer.nektarine_N ;
|
|
need_N = DictGer.bedarf_N ;
|
|
needle_N = DictGer.nadel__N ;
|
|
needless_A = DictGer.unnoetig_A ;
|
|
nefarious_A = DictGer.beruechtigt_A ;
|
|
negation_N = DictGer.negation_N ;
|
|
negative_A = DictGer.negativ_A ;
|
|
neglect_V2 = P.dirV2 (DictGer.missachten_V) ;
|
|
neglectful_A = DictGer.nachlaessig_A ;
|
|
negligee_N = DictGer.neglige_N ;
|
|
negligence_N = DictGer.fahrlaessigkeit_N ;
|
|
negligent_A = DictGer.fahrlaessig_A ;
|
|
negotiate_V = DictGer.verhandeln_V ;
|
|
negotiate_V2 = P.dirV2 (DictGer.verhandeln_V) ;
|
|
negotiation_N = DictGer.verhandlung_N ;
|
|
neighbour_N = DictGer.nachbarin_N ;
|
|
neighbourhood_N = DictGer.nachbarschaft_N ;
|
|
neologism_N = DictGer.neologismus_N ;
|
|
nephew_N = DictGer.neffe_N ;
|
|
nerve_N = DictGer.nerv_N ;
|
|
nervous_A = DictGer.nervoes_A ;
|
|
nest_N = DictGer.nest_N ;
|
|
net_N = DictGer.netz_N ;
|
|
nether_A = DictGer.unterirdisch_A ;
|
|
nettle_N = DictGer.brennnessel_N ;
|
|
network_N = DictGer.netzwerk_N ;
|
|
neuralgia_N = DictGer.neuralgie_N ;
|
|
neuralgic_A = DictGer.neuralgisch_A ;
|
|
neurosis_N = DictGer.neurose_N ;
|
|
neurotic_A = DictGer.neurotisch_A ;
|
|
neuter_A = DictGer.geschlechtslos_A ;
|
|
neutral_A = DictGer.neutral_A ;
|
|
neutrality_N = DictGer.neutralitaet_N ;
|
|
neutron_N = DictGer.neutron_N ;
|
|
new_A = LexiconGer.new_A ;
|
|
newfangled_A = DictGer.neumodisch_A ;
|
|
news_N = DictGer.nachricht_N ;
|
|
newscaster_N = DictGer.nachrichtensprecher_N ;
|
|
newspaper_N = LexiconGer.newspaper_N ;
|
|
newsroom_N = DictGer.redaktion_N ;
|
|
newt_N = DictGer.molch_N ;
|
|
nexus_N = DictGer.verbindung_N ;
|
|
nice_A = DictGer.angenehm_A ;
|
|
niche_N = DictGer.nische_N ;
|
|
nickname_N = DictGer.beiname_N ;
|
|
niece_N = DictGer.nichte_N ;
|
|
nifty_A = DictGer.elegant_A ;
|
|
nigger_N = DictGer.kaffer_N ;
|
|
night_N = LexiconGer.night_N ;
|
|
nightcap_N = DictGer.schlafmuetze_N ;
|
|
nightclub_N = DictGer.nachtklub_N ;
|
|
nightdress_N = DictGer.nachthemd_N ;
|
|
nightgown_N = DictGer.nachthemd_N ;
|
|
nightie_N = DictGer.nachthemd_N ;
|
|
nightingale_N = DictGer.nachtigall_N ;
|
|
nightjar_N = DictGer.ziegenmelker_N ;
|
|
nightmare_N = DictGer.albdruck_N ;
|
|
nightmarish_A = DictGer.albtraumhaft_A ;
|
|
nightshade_N = DictGer.tollkirsche_N ;
|
|
nimble_A = DictGer.flink_A ;
|
|
nimbus_N = DictGer.nimbus_N ;
|
|
nincompoop_N = DictGer.dummkopf_N ;
|
|
nit_N = DictGer.nisse_N ;
|
|
nitrogen_N = DictGer.nitrogen_N ;
|
|
noble_N = DictGer.aristokrat_N ;
|
|
nod_V = DictGer.nicken_V ;
|
|
nod_V2 = P.dirV2 (DictGer.nicken_V) ;
|
|
node_N = DictGer.ecke_N ;
|
|
noggin_N = DictGer.birne_N ;
|
|
noise_N = DictGer.stoerung_N ;
|
|
noisome_A = DictGer.ekelhaft_A ;
|
|
noisy_A = DictGer.laut_A ;
|
|
nomad_N = DictGer.nomade_N ;
|
|
nomenclature_N = DictGer.nomenklatur_N ;
|
|
nominate_V2 = P.dirV2 (DictGer.nominieren_V) ;
|
|
nominee_N = DictGer.kandidat_N ;
|
|
nonchalant_A = DictGer.gleichgueltig_A ;
|
|
nonstop_A = DictGer.durchgehend_A ;
|
|
nook_N = DictGer.alkoven_N ;
|
|
noon_N = DictGer.mittag_N ;
|
|
noose_N = DictGer.schlinge_N ;
|
|
norm_N = DictGer.norm_N ;
|
|
normal_A = DictGer.normal_A ;
|
|
normalization_N = DictGer.normalisierung_N ;
|
|
normative_A = DictGer.normativ_A ;
|
|
nose_N = LexiconGer.nose_N ;
|
|
nostalgia_N = DictGer.nostalgie_N ;
|
|
nostalgic_A = DictGer.nostalgisch_A ;
|
|
notable_A = DictGer.bemerkenswert_A ;
|
|
notary_N = DictGer.notar_N ;
|
|
note_N = DictGer.notiz_N ;
|
|
notebook_N = DictGer.notebook_N ;
|
|
notice_N = DictGer.bekanntmachung_N ;
|
|
noticeable_A = DictGer.auffaellig_A ;
|
|
notification_N = DictGer.benachrichtigung_N ;
|
|
notify_V2 = P.dirV2 (DictGer.benachrichtigen_V) ;
|
|
notion_N = DictGer.ahnung_N ;
|
|
notorious_A = DictGer.beruechtigt_A ;
|
|
noun_N = DictGer.substantiv_N ;
|
|
nova_N = DictGer.nova_N ;
|
|
novel_A = DictGer.neu_A ;
|
|
novelty_N = DictGer.neuheit_N ;
|
|
novice_N = DictGer.neuling_N ;
|
|
nuance_N = DictGer.nuance_N ;
|
|
nucleus_N = DictGer.atomkern_N ;
|
|
nudity_N = DictGer.nacktheit_N ;
|
|
nugatory_A = DictGer.belanglos_A ;
|
|
nuisance_N = DictGer.belaestigung_N ;
|
|
number_N = LexiconGer.number_N ;
|
|
numeral_N = DictGer.zahl_N ;
|
|
numerator_N = DictGer.zaehler_N ;
|
|
numeric_A = DictGer.numerisch_A ;
|
|
numerical_A = DictGer.numerisch_A ;
|
|
numerous_A = DictGer.zahlreich_A ;
|
|
nurse_N = DictGer.krankenpfleger_N ;
|
|
nursery_N = DictGer.kindergarten_N ;
|
|
nut_N = DictGer.birne_N ;
|
|
nutrition_N = DictGer.ernaehrung_N ;
|
|
nutritious_A = DictGer.nahrhaft_A ;
|
|
nutty_A = DictGer.bekloppt_A ;
|
|
nuzzle_V = DictGer.haetscheln_V ;
|
|
nuzzle_V2 = P.dirV2 (DictGer.haetscheln_V) ;
|
|
nymph_N = DictGer.nymphe_N ;
|
|
oak_N = DictGer.eiche_N ;
|
|
oar_N = DictGer.ruder_N ;
|
|
oasis_N = DictGer.oase_N ;
|
|
oast_N = DictGer.darre_N ;
|
|
oat_N = DictGer.hafer_N ;
|
|
oath_N = DictGer.eid_N ;
|
|
obedient_A = DictGer.gehorsam_A ;
|
|
obelisk_N = DictGer.kreuz_N ;
|
|
obese_A = DictGer.fettleibig_A ;
|
|
obey_V = DictGer.gehorchen_V ;
|
|
obey_V2 = P.dirV2 (DictGer.gehorchen_V) ;
|
|
obfuscate_V2 = P.dirV2 (DictGer.verschleiern_V) ;
|
|
obituary_N = DictGer.nachruf_N ;
|
|
object_N = DictGer.gegenstand_N ;
|
|
objection_N = DictGer.einwand_N ;
|
|
objective_A = DictGer.objektiv_A ;
|
|
obligation_N = DictGer.pflicht_N ;
|
|
obliging_A = DictGer.verbindlich_A ;
|
|
oblivious_A = DictGer.vergesslich_A ;
|
|
oblong_A = DictGer.laenglich_A ;
|
|
oboe_N = DictGer.oboe_N ;
|
|
obscene_A = DictGer.obszoen_A ;
|
|
obscure_A = DictGer.duester_A ;
|
|
observatory_N = DictGer.observatorium_N ;
|
|
observe_V = DictGer.beobachten_V ;
|
|
observe_V2 = P.dirV2 (DictGer.beobachten_V) ;
|
|
observer_N = DictGer.beobachter_N ;
|
|
obsolescent_A = DictGer.veraltend_A ;
|
|
obsolete_A = DictGer.obsolet_A ;
|
|
obstacle_N = DictGer.hindernis_N ;
|
|
obstinacy_N = DictGer.sturheit_N ;
|
|
obstinate_A = DictGer.hartnaeckig_A ;
|
|
obstruct_V2 = P.dirV2 (DictGer.behindern_V) ;
|
|
obstruction_N = DictGer.obstruktion_N ;
|
|
obtain_V = DictGer.bestehen_V ;
|
|
obtain_V2 = P.dirV2 (DictGer.bestehen_V) ;
|
|
obtainable_A = DictGer.verfuegbar_A ;
|
|
obtuse_A = DictGer.beschraenkt_A ;
|
|
obviate_V2 = P.dirV2 (DictGer.machen_2_V) ;
|
|
obvious_A = DictGer.offensichtlich_A ;
|
|
occasion_N = DictGer.gelegenheit_N ;
|
|
occasional_A = DictGer.gelegentlich_A ;
|
|
occupant_N = DictGer.besatzer_N ;
|
|
occupation_N = DictGer.beruf_N ;
|
|
occupy_V = DictGer.besetzen_V ;
|
|
occupy_V2 = P.dirV2 (DictGer.besetzen_V) ;
|
|
occur_V = DictGer.passieren_V ;
|
|
occurrence_N = DictGer.vorfall_N ;
|
|
ocean_N = DictGer.ozean_N ;
|
|
octagon_N = DictGer.achteck_N ;
|
|
octane_N = DictGer.octan_N ;
|
|
octet_N = DictGer.oktett_N ;
|
|
octopus_N = DictGer.tintenfisch_N ;
|
|
odd_A = DictGer.einzeln_A ;
|
|
odour_N = DictGer.geruch_N ;
|
|
odyssey_N = DictGer.odyssee_N ;
|
|
oesophagus_N = DictGer.speiseroehre_N ;
|
|
offal_N = DictGer.abfall_N ;
|
|
offend_V = DictGer.beleidigen_V ;
|
|
offend_V2 = P.dirV2 (DictGer.beleidigen_V) ;
|
|
offensive_A = DictGer.offensiv_A ;
|
|
offer_N = DictGer.angebot_N ;
|
|
offhand_A = DictGer.nachlaessig_A ;
|
|
office_N = DictGer.amt_N ;
|
|
officer_N = DictGer.offizier_N ;
|
|
official_A = DictGer.amtlich_A ;
|
|
offspring_N = DictGer.abkoemmling_N ;
|
|
ogre_N = DictGer.oger_N ;
|
|
oil_N = LexiconGer.oil_N ;
|
|
oily_A = DictGer.oelig_A ;
|
|
ointment_N = DictGer.salbe_N ;
|
|
okapi_N = DictGer.okapi_N ;
|
|
old_A = LexiconGer.old_A ;
|
|
oleander_N = DictGer.oleander_N ;
|
|
oligarchy_N = DictGer.oligarchie_N ;
|
|
olive_N = DictGer.olive_N ;
|
|
olympiad_N = DictGer.olympiade_N ;
|
|
omega_N = DictGer.omega_N ;
|
|
ominous_A = DictGer.ominoes_A ;
|
|
omnibus_N = DictGer.bus_N ;
|
|
omnipotent_A = DictGer.allmaechtig_A ;
|
|
onerous_A = DictGer.beschwerlich_A ;
|
|
ongoing_A = DictGer.laufend_A ;
|
|
onion_N = DictGer.zwiebel_N ;
|
|
onomatopoeia_N = DictGer.lautmalerei_N ;
|
|
ontology_N = DictGer.ontologie_N ;
|
|
onyx_N = DictGer.onyx_N ;
|
|
opal_N = DictGer.opal_N ;
|
|
opaque_A = DictGer.undurchsichtig_A ;
|
|
open_A = DictGer.offen_A ;
|
|
open_V2 = LexiconGer.open_V2 ;
|
|
opener_N = DictGer.oeffner_N ;
|
|
opening_N = DictGer.eroeffnung_N ;
|
|
opera_N = DictGer.oper_N ;
|
|
operation_N = DictGer.betrieb_N ;
|
|
operator_N = DictGer.betreiber_N ;
|
|
opinion_N = DictGer.anschauung_N ;
|
|
opponent_N = DictGer.gegenspieler_N ;
|
|
opportunist_N = DictGer.opportunist_N ;
|
|
opportunity_N = DictGer.gelegenheit_N ;
|
|
oppose_V = DictGer.widersprechen_V ;
|
|
oppose_V2 = P.dirV2 (DictGer.widersprechen_V) ;
|
|
opposition_N = DictGer.opposition_N ;
|
|
oppress_V2 = P.dirV2 (DictGer.unterdruecken_V) ;
|
|
opt_V = DictGer.optieren_V ;
|
|
optician_N = DictGer.optiker_N ;
|
|
optics_N = DictGer.optik_N ;
|
|
optimism_N = DictGer.zuversicht_N ;
|
|
optimist_N = DictGer.optimist_N ;
|
|
optimistic_A = DictGer.optimistisch_A ;
|
|
optional_A = DictGer.freiwillig_A ;
|
|
opulent_A = DictGer.opulent_A ;
|
|
oral_A = DictGer.muendlich_A ;
|
|
orange_N = DictGer.apfelsine_N ;
|
|
orator_N = DictGer.redner_N ;
|
|
orb_N = DictGer.kugel_N ;
|
|
orbit_N = DictGer.orbit_N ;
|
|
orbital_A = DictGer.orbital_A ;
|
|
orchard_N = DictGer.obstgarten_N ;
|
|
orchestra_N = DictGer.orchestergraben_N ;
|
|
orchid_N = DictGer.orchidee_N ;
|
|
ordeal_N = DictGer.gottesurteil_N ;
|
|
order_N = DictGer.befehl_N ;
|
|
orderly_A = DictGer.ordentlich_A ;
|
|
ordinary_A = DictGer.gewoehnlich_A ;
|
|
ordnance_N = DictGer.artillerie_N ;
|
|
ore_N = DictGer.erz_N ;
|
|
organ_N = DictGer.organ_N ;
|
|
organic_A = DictGer.organisch_A ;
|
|
organism_N = DictGer.organismus_N ;
|
|
organization_N = DictGer.ordnung_N ;
|
|
organize_V2 = P.dirV2 (DictGer.organisieren_V) ;
|
|
organizer_N = DictGer.organisator_N ;
|
|
orgasm_N = DictGer.orgasmus_N ;
|
|
orgy_N = DictGer.orgie_N ;
|
|
origin_N = DictGer.anfang_N ;
|
|
original_A = DictGer.original_A ;
|
|
originate_V = DictGer.entspringen_V ;
|
|
originate_V2 = P.dirV2 (DictGer.entspringen_V) ;
|
|
ornithologist_N = DictGer.ornithologe_N ;
|
|
orphan_N = DictGer.schusterjunge_N ;
|
|
orphanage_N = DictGer.waisenhaus_N ;
|
|
orthodox_A = DictGer.orthodox_A ;
|
|
orthogonal_A = DictGer.orthogonal_A ;
|
|
orthography_N = DictGer.orthografie_N ;
|
|
ortolan_N = DictGer.ortolan_N ;
|
|
oscillate_V = DictGer.pendeln_V ;
|
|
oscillate_V2 = P.dirV2 (DictGer.pendeln_V) ;
|
|
oscillation_N = DictGer.oszillation_N ;
|
|
oscilloscope_N = DictGer.oszilloskop_N ;
|
|
ostensible_A = DictGer.angeblich_A ;
|
|
ostracize_V2 = P.dirV2 (DictGer.verbannen_V) ;
|
|
otter_N = DictGer.otter_N ;
|
|
ounce_N = DictGer.unze_N ;
|
|
oust_V = DictGer.verdraengen_V ;
|
|
oust_V2 = P.dirV2 (DictGer.verdraengen_V) ;
|
|
outcast_N = DictGer.aussenseiter_N ;
|
|
outcome_N = DictGer.ausgang_N ;
|
|
outdated_A = DictGer.veraltet_A ;
|
|
outfit_N = DictGer.outfit_N ;
|
|
outlet_N = DictGer.steckdose_N ;
|
|
outlier_N = DictGer.ausreisser_N ;
|
|
outline_N = DictGer.kontur_N ;
|
|
outlive_V2 = P.dirV2 (DictGer.ueberleben_V) ;
|
|
outlook_N = DictGer.ausblick_N ;
|
|
outrageous_A = DictGer.ungeheuerlich_A ;
|
|
outset_N = DictGer.anfang_N ;
|
|
outside_N = DictGer.aussenseite_N ;
|
|
outsider_N = DictGer.aussenseiter_N ;
|
|
outsmart_V2 = P.dirV2 (DictGer.ueberlisten_V) ;
|
|
ouzo_N = DictGer.ouzo_N ;
|
|
ovary_N = DictGer.eierstock_N ;
|
|
oven_N = DictGer.ofen_N ;
|
|
overbearing_A = DictGer.anmassend_A ;
|
|
overcoat_N = DictGer.mantel_N ;
|
|
overcome_V = DictGer.ueberwinden_V ;
|
|
overcome_V2 = P.dirV2 (DictGer.ueberwinden_V) ;
|
|
overdo_V2 = P.dirV2 (DictGer.uebertreiben_V) ;
|
|
overdue_A = DictGer.ueberfaellig_A ;
|
|
overestimate_V2 = P.dirV2 (DictGer.ueberschaetzen_V) ;
|
|
overjoyed_A = DictGer.uebergluecklich_A ;
|
|
overpass_N = DictGer.ueberfuehrung_N ;
|
|
overseer_N = DictGer.aufseher_N ;
|
|
overstate_V2 = P.dirV2 (DictGer.uebertreiben_V) ;
|
|
overtake_V2 = P.dirV2 (DictGer.ueberholen_V) ;
|
|
overthrow_V2 = P.dirV2 (DictGer.stuerzen_6_V) ;
|
|
overtime_N = DictGer.verlaengerung_N ;
|
|
overture_N = DictGer.angebot_N ;
|
|
overweight_A = DictGer.uebergewichtig_A ;
|
|
oviparous_A = DictGer.eierlegend_A ;
|
|
owl_N = DictGer.eule_N ;
|
|
own_V = DictGer.besitzen_V ;
|
|
own_V2 = P.dirV2 (DictGer.besitzen_V) ;
|
|
owner_N = DictGer.besitzer_N ;
|
|
ox_N = DictGer.ochse_N ;
|
|
oxidation_N = DictGer.oxidation_N ;
|
|
oxide_N = DictGer.oxid_N ;
|
|
oxygen_N = DictGer.sauerstoff_N ;
|
|
oyster_N = DictGer.auster__N ;
|
|
pa_N = DictGer.opa_N ;
|
|
pace_N = DictGer.geschwindigkeit_N ;
|
|
pacemaker_N = DictGer.herzschrittmacher_N ;
|
|
pacific_A = DictGer.friedlich_A ;
|
|
pacifist_N = DictGer.pazifist_N ;
|
|
package_N = DictGer.paket_N ;
|
|
paddle_N = DictGer.tischtennisschlaeger_N ;
|
|
pagan_A = DictGer.heidnisch_A ;
|
|
page_N = DictGer.page__N ;
|
|
pagoda_N = DictGer.pagode_N ;
|
|
pail_N = DictGer.eimer_N ;
|
|
pain_N = DictGer.schmerz_N ;
|
|
painful_A = DictGer.schmerzhaft_A ;
|
|
painkiller_N = DictGer.schmerzmittel_N ;
|
|
painstaking_A = DictGer.akribisch_A ;
|
|
paint_N = DictGer.farbe_N ;
|
|
paintbrush_N = DictGer.pinsel_N ;
|
|
painter_N = DictGer.maler_N ;
|
|
pair_N = DictGer.paar_N ;
|
|
palace_N = DictGer.palast__N ;
|
|
palanquin_N = DictGer.saenfte_N ;
|
|
palatable_A = DictGer.annehmbar_A ;
|
|
palatal_A = DictGer.palatal_A ;
|
|
palate_N = DictGer.gaumen_N ;
|
|
palaver_N = DictGer.palaver_N ;
|
|
pale_A = DictGer.blass_A ;
|
|
palette_N = DictGer.palette_N ;
|
|
palindrome_N = DictGer.palindrom_N ;
|
|
palisade_N = DictGer.palisade_N ;
|
|
pallet_N = DictGer.palette_N ;
|
|
palm_N = DictGer.handflaeche_N ;
|
|
palpable_A = DictGer.greifbar_A ;
|
|
pamper_V2 = P.dirV2 (DictGer.haetscheln_V) ;
|
|
pan_N = DictGer.pfanne_N ;
|
|
panacea_N = DictGer.allheilmittel_N ;
|
|
panache_N = DictGer.schwung_N ;
|
|
pancake_N = DictGer.pfannkuchen_N ;
|
|
pancreas_N = DictGer.bauchspeicheldruese_N ;
|
|
pancreatic_A = DictGer.pankreatisch_A ;
|
|
panda_N = DictGer.panda_N ;
|
|
pane_N = DictGer.glasscheibe_N ;
|
|
panegyric_N = DictGer.lobrede_N ;
|
|
panel_N = DictGer.platte_N ;
|
|
panicky_A = DictGer.panikartig_A ;
|
|
panorama_N = DictGer.panorama__N ;
|
|
pansy_N = DictGer.stiefmuetterchen_N ;
|
|
pantheist_N = DictGer.pantheist_N ;
|
|
pantheon_N = DictGer.pantheon_N ;
|
|
panther_N = DictGer.panter_N ;
|
|
pantomime_N = DictGer.pantomime_N ;
|
|
pantry_N = DictGer.speisekammer_N ;
|
|
pap_N = DictGer.brei_N ;
|
|
papaya_N = DictGer.papaya_N ;
|
|
paper_N = LexiconGer.paper_N ;
|
|
paperweight_N = DictGer.briefbeschwerer_N ;
|
|
papyrus_N = DictGer.papyrus_N ;
|
|
parable_N = DictGer.parabel_N ;
|
|
parabola_N = DictGer.parabel_N ;
|
|
parachute_N = DictGer.fallschirm_N ;
|
|
parachutist_N = DictGer.fallschirmspringer_N ;
|
|
parade_N = DictGer.abfolge_N ;
|
|
paradigm_N = DictGer.beispiel_N ;
|
|
paradox_N = DictGer.paradox_N ;
|
|
paradoxical_A = DictGer.paradox_A ;
|
|
paragon_N = DictGer.vorbild_N ;
|
|
paragraph_N = DictGer.absatz_N ;
|
|
parakeet_N = DictGer.sittich_N ;
|
|
parallel_A = DictGer.parallel_A ;
|
|
parallelogram_N = DictGer.parallelogramm_N ;
|
|
paralysis_N = DictGer.laehmung_N ;
|
|
paralyze_V2 = P.dirV2 (DictGer.laehmen_V) ;
|
|
parameter_N = DictGer.parameter_N ;
|
|
paranoid_A = DictGer.paranoid_A ;
|
|
parasite_N = DictGer.parasit_N ;
|
|
parasitic_A = DictGer.parasitaer_A ;
|
|
parasol_N = DictGer.sonnenschirm_N ;
|
|
paratrooper_N = DictGer.fallschirmjaeger_N ;
|
|
parcel_N = DictGer.paket_N ;
|
|
parchment_N = DictGer.pergament__N ;
|
|
pardon_N = DictGer.begnadigung_N ;
|
|
parental_A = DictGer.elterlich_A ;
|
|
pariah_N = DictGer.paria_N ;
|
|
parish_N = DictGer.gemeinde_N ;
|
|
parka_N = DictGer.anorak_N ;
|
|
parlance_N = DictGer.ausdrucksweise_N ;
|
|
parliament_N = DictGer.parlament__N ;
|
|
parliamentarian_N = DictGer.parlamentarier_N ;
|
|
parmesan_N = DictGer.parmesankaese_N ;
|
|
parochial_A = DictGer.beschraenkt_A ;
|
|
parody_N = DictGer.parodie_N ;
|
|
parole_N = DictGer.bewaehrung_N ;
|
|
paroxysm_N = DictGer.paroxysmus_N ;
|
|
part_N = DictGer.rolle_N ;
|
|
partial_A = DictGer.parteiisch_A ;
|
|
participant_N = DictGer.teilnehmer_N ;
|
|
participation_N = DictGer.beteiligung_N ;
|
|
participle_N = DictGer.partizip_N ;
|
|
particle_N = DictGer.partikel_N ;
|
|
particular_A = DictGer.bestimmt_A ;
|
|
parting_N = DictGer.abschied_N ;
|
|
partisan_N = DictGer.partisane_N ;
|
|
partner_N = DictGer.partner_N ;
|
|
partnership_N = DictGer.partnerschaft_N ;
|
|
partridge_N = DictGer.rebhuhn_N ;
|
|
parturition_N = DictGer.geburt_N ;
|
|
party_N = DictGer.feier_N ;
|
|
parvenu_N = DictGer.emporkoemmling_N ;
|
|
pasha_N = DictGer.pascha_N ;
|
|
passage_N = DictGer.passage_N ;
|
|
passenger_N = DictGer.fahrgast_N ;
|
|
passion_N = DictGer.leidenschaft_N ;
|
|
passionate_A = DictGer.leidenschaftlich_A ;
|
|
passport_N = DictGer.pass_N ;
|
|
password_N = DictGer.passwort_N ;
|
|
past_N = DictGer.vergangenheit_N ;
|
|
paste_N = DictGer.paste_N ;
|
|
pasteurize_V2 = P.dirV2 (DictGer.pasteurisieren_V) ;
|
|
pastiche_N = DictGer.potpourri_N ;
|
|
pastille_N = DictGer.pastille_N ;
|
|
pastime_N = DictGer.zeitvertreib_N ;
|
|
pastor_N = DictGer.pastor_N ;
|
|
pastry_N = DictGer.gebaeck_N ;
|
|
pasture_N = DictGer.weide_N ;
|
|
patch_N = DictGer.flicken_N ;
|
|
patent_N = DictGer.patent_N ;
|
|
paternoster_N = DictGer.vaterunser_N ;
|
|
path_N = DictGer.pfad_N ;
|
|
pathetic_A = DictGer.bemitleidenswert_A ;
|
|
pathological_A = DictGer.krankhaft_A ;
|
|
pathology_N = DictGer.pathologie_N ;
|
|
patient_A = DictGer.geduldig_A ;
|
|
patio_N = DictGer.patio_N ;
|
|
patrician_N = DictGer.patrizier_N ;
|
|
patrimony_N = DictGer.patrimonium_N ;
|
|
patriot_N = DictGer.patriot_N ;
|
|
patriotic_A = DictGer.patriotisch_A ;
|
|
patrol_N = DictGer.patrouille_N ;
|
|
pattern_N = DictGer.modell_N ;
|
|
paunch_N = DictGer.pansen_N ;
|
|
pauperism_N = DictGer.pauperismus_N ;
|
|
pavement_N = DictGer.asphalt_N ;
|
|
pavilion_N = DictGer.pavillon_N ;
|
|
paw_N = DictGer.pfote_N ;
|
|
pawn_N = DictGer.bauer_N ;
|
|
pawnbroker_N = DictGer.pfandleiher_N ;
|
|
pawnshop_N = DictGer.pfandhaus_N ;
|
|
pay_V = DictGer.bezahlen_3_V ;
|
|
pay_V2 = P.dirV2 (DictGer.bezahlen_3_V) ;
|
|
payday_N = DictGer.zahltag_N ;
|
|
payment_N = DictGer.zahlung_N ;
|
|
pea_N = DictGer.erbse_N ;
|
|
peace_N = LexiconGer.peace_N ;
|
|
peaceful_A = DictGer.friedfertig_A ;
|
|
peach_N = DictGer.pfirsich_N ;
|
|
peacock_N = DictGer.pfau_N ;
|
|
peafowl_N = DictGer.pfau_N ;
|
|
peak_N = DictGer.gipfel_N ;
|
|
peanut_N = DictGer.erdnuss_N ;
|
|
pear_N = DictGer.birnbaum_N ;
|
|
pearl_N = DictGer.perle_N ;
|
|
peasant_N = DictGer.bauer_N ;
|
|
peat_N = DictGer.torf_N ;
|
|
pebble_N = DictGer.kieselstein_N ;
|
|
peckish_A = DictGer.hungrig_A ;
|
|
pedagogic_A = DictGer.paedagogisch_A ;
|
|
pedagogue_N = DictGer.paedagoge_N ;
|
|
pedal_N = DictGer.pedal_N ;
|
|
peddler_N = DictGer.hausierer_N ;
|
|
pedestal_N = DictGer.piedestal_N ;
|
|
peek_V = DictGer.gucken_V ;
|
|
peel_V = DictGer.schaelen_V ;
|
|
peel_V2 = P.dirV2 (DictGer.schaelen_V) ;
|
|
peephole_N = DictGer.spion_N ;
|
|
peer_V = DictGer.spaehen_V ;
|
|
peevish_A = DictGer.muerrisch_A ;
|
|
peg_N = DictGer.stift_N ;
|
|
pejorative_A = DictGer.abschaetzig_A ;
|
|
pelican_N = DictGer.pelikan_N ;
|
|
pelt_N = DictGer.balg_N ;
|
|
pelvis_N = DictGer.becken_N ;
|
|
pen_N = LexiconGer.pen_N ;
|
|
penalty_N = DictGer.elfmeter_N ;
|
|
penchant_N = DictGer.hang_N ;
|
|
pencil_N = DictGer.bleistift_N ;
|
|
pendulum_N = DictGer.pendel_N ;
|
|
penetrable_A = DictGer.durchlaessig_A ;
|
|
penetrate_V = DictGer.penetrieren_V ;
|
|
penetrate_V2 = P.dirV2 (DictGer.penetrieren_V) ;
|
|
penetration_N = DictGer.penetration_N ;
|
|
penguin_N = DictGer.pinguin_N ;
|
|
penicillin_N = DictGer.penicillin_N ;
|
|
peninsula_N = DictGer.halbinsel_N ;
|
|
penis_N = DictGer.glied_N ;
|
|
penitentiary_N = DictGer.gefaengnis_N ;
|
|
penknife_N = DictGer.taschenmesser_N ;
|
|
penny_N = DictGer.penny_N ;
|
|
pension_N = DictGer.pension_N ;
|
|
pensioner_N = DictGer.rentner_N ;
|
|
pentagon_N = DictGer.fuenfeck_N ;
|
|
penthouse_N = DictGer.penthouse_N ;
|
|
pepper_N = DictGer.pfeffer_N ;
|
|
pepsin_N = DictGer.pepsin_N ;
|
|
percent_N = DictGer.prozent_N ;
|
|
perception_N = DictGer.wahrnehmung_N ;
|
|
perch_N = DictGer.barsch_N ;
|
|
percolate_V = DictGer.filtrieren_V ;
|
|
percolate_V2 = P.dirV2 (DictGer.filtrieren_V) ;
|
|
peremptory_A = DictGer.entschieden_A ;
|
|
perfect_A = DictGer.perfekt_A ;
|
|
perform_V = DictGer.spielen_6_V ;
|
|
perform_V2 = P.dirV2 (DictGer.spielen_6_V) ;
|
|
performance_N = DictGer.auffuehrung_N ;
|
|
perfume_N = DictGer.duft_N ;
|
|
perfumer_N = DictGer.parfuemeur_N ;
|
|
perihelion_N = DictGer.perihel_N ;
|
|
peril_N = DictGer.gefahr_N ;
|
|
perilous_A = DictGer.gefahrvoll_A ;
|
|
perimeter_N = DictGer.umfang_N ;
|
|
periphery_N = DictGer.peripherie_N ;
|
|
periscope_N = DictGer.periskop_N ;
|
|
perish_V = DictGer.verderben_V ;
|
|
perish_V2 = P.dirV2 (DictGer.verderben_V) ;
|
|
periwinkle_N = DictGer.immergruen_N ;
|
|
perjury_N = DictGer.meineid_N ;
|
|
permanent_A = DictGer.bestaendig_A ;
|
|
permissible_A = DictGer.zulaessig_A ;
|
|
permission_N = DictGer.erlaubnis_N ;
|
|
permit_V = DictGer.erlauben_V ;
|
|
permit_V2 = P.dirV2 (DictGer.erlauben_V) ;
|
|
pernicious_A = DictGer.boesartig_A ;
|
|
peroration_N = DictGer.zusammenfassung_N ;
|
|
perpendicular_A = DictGer.rechtwinklig_A ;
|
|
perpetrator_N = DictGer.taeter_N ;
|
|
perplexed_A = DictGer.perplex_A ;
|
|
persecution_N = DictGer.verfolgung_N ;
|
|
persiflage_N = DictGer.persiflage_N ;
|
|
persistent_A = DictGer.staendig_A ;
|
|
person_N = LexiconGer.person_N ;
|
|
personable_A = DictGer.ansehnlich_A ;
|
|
personage_N = DictGer.persoenlichkeit_N ;
|
|
personal_A = DictGer.persoenlich_A ;
|
|
personality_N = DictGer.persoenlichkeit_N ;
|
|
perspective_N = DictGer.aussicht_N ;
|
|
perspiration_N = DictGer.sweating_N ;
|
|
persuade_V2 = P.dirV2 (DictGer.ueberreden_V) ;
|
|
persuasion_N = DictGer.ueberzeugung_N ;
|
|
pertain_V = DictGer.betreffen_V ;
|
|
pertinent_A = DictGer.angemessen_A ;
|
|
perturbation_N = DictGer.stoerung_N ;
|
|
peruke_N = DictGer.peruecke_N ;
|
|
pesky_A = DictGer.laestig_A ;
|
|
peso_N = DictGer.peso_N ;
|
|
pessimist_N = DictGer.pessimist_N ;
|
|
pessimistic_A = DictGer.pessimistisch_A ;
|
|
pesticide_N = DictGer.pestizid_N ;
|
|
pestilence_N = DictGer.pest_N ;
|
|
pet_N = DictGer.haustier_N ;
|
|
petal_N = DictGer.bluetenblatt_N ;
|
|
petition_N = DictGer.petition_N ;
|
|
petrifaction_N = DictGer.versteinerung_N ;
|
|
petrify_V = DictGer.erstarren_V ;
|
|
petrify_V2 = P.dirV2 (DictGer.erstarren_V) ;
|
|
petrol_N = DictGer.benzin_N ;
|
|
petticoat_N = DictGer.unterrock_N ;
|
|
petty_A = DictGer.gering_A ;
|
|
petulant_A = DictGer.launisch_A ;
|
|
pfennig_N = DictGer.pfennig_N ;
|
|
phallic_A = DictGer.phallisch_A ;
|
|
phallus_N = DictGer.phallus_N ;
|
|
phantasmagoria_N = DictGer.phantasmagorie_N ;
|
|
phantom_N = DictGer.phantom_N ;
|
|
pharaoh_N = DictGer.pharao_N ;
|
|
pharmaceutical_A = DictGer.pharmazeutisch_A ;
|
|
pharmacist_N = DictGer.apotheker_N ;
|
|
pharmacological_A = DictGer.pharmakologisch_A ;
|
|
pharmacy_N = DictGer.apotheke_N ;
|
|
phenol_N = DictGer.phenol_N ;
|
|
phenomenon_N = DictGer.phaenomen_N ;
|
|
philanthropist_N = DictGer.philanthrop_N ;
|
|
philatelist_N = DictGer.briefmarkensammler_N ;
|
|
philological_A = DictGer.philologisch_A ;
|
|
philologist_N = DictGer.philologe_N ;
|
|
philosopher_N = DictGer.philosoph_N ;
|
|
philosophical_A = DictGer.philosophisch_A ;
|
|
philosophize_V = DictGer.philosophieren_V ;
|
|
philosophy_N = DictGer.philosophie_N ;
|
|
phlegm_N = DictGer.nasenschleim_N ;
|
|
phlegmatic_A = DictGer.phlegmatisch_A ;
|
|
phobia_N = DictGer.phobie_N ;
|
|
phoenix_N = DictGer.phoenix_7_N ;
|
|
phone_N = DictGer.fernsprecher_N ;
|
|
phoneme_N = DictGer.phonem_N ;
|
|
phosphorus_N = DictGer.phosphor_N ;
|
|
photo_N = DictGer.bild_N ;
|
|
photogenic_A = DictGer.fotogen_A ;
|
|
photographer_N = DictGer.fotograf_N ;
|
|
photography_N = DictGer.fotografie_N ;
|
|
photon_N = DictGer.photon_N ;
|
|
photosynthesis_N = DictGer.photosynthese_N ;
|
|
phrase_N = DictGer.phrase_N ;
|
|
phylum_N = DictGer.stamm_N ;
|
|
physical_A = DictGer.koerperlich_A ;
|
|
physician_N = DictGer.arzt_N ;
|
|
physicist_N = DictGer.physiker_N ;
|
|
physiognomy_N = DictGer.physiognomie_N ;
|
|
physiological_A = DictGer.physiologisch_A ;
|
|
physiologist_N = DictGer.physiologe_N ;
|
|
physiotherapy_N = DictGer.physiotherapie_N ;
|
|
pianist_N = DictGer.klavierspieler_N ;
|
|
piano_N = DictGer.klavier_N ;
|
|
piccolo_N = DictGer.piccolofloete_N ;
|
|
pickpocket_N = DictGer.taschendieb_N ;
|
|
picture_N = DictGer.abbild_N ;
|
|
picturesque_A = DictGer.pittoresk_A ;
|
|
pie_N = DictGer.torte_N ;
|
|
piece_N = DictGer.stueck_N ;
|
|
pier_N = DictGer.pfeiler_N ;
|
|
pig_N = DictGer.bulle_N ;
|
|
pigeon_N = DictGer.taube_N ;
|
|
piglet_N = DictGer.ferkel_N ;
|
|
pigment_N = DictGer.farbstoff_N ;
|
|
pigsty_N = DictGer.koben_N ;
|
|
pigtail_N = DictGer.zopf_N ;
|
|
pike_N = DictGer.hecht_N ;
|
|
pile_N = DictGer.halde_N ;
|
|
pilfer_V = DictGer.klauen_V ;
|
|
pilfer_V2 = P.dirV2 (DictGer.klauen_V) ;
|
|
pilferer_N = DictGer.dieb_N ;
|
|
pilgrim_N = DictGer.pilger_N ;
|
|
pilgrimage_N = DictGer.wallfahrt_N ;
|
|
pill_N = DictGer.pille_N ;
|
|
pillar_N = DictGer.pfeiler_N ;
|
|
pillbox_N = DictGer.bunker_N ;
|
|
pillory_N = DictGer.pranger_N ;
|
|
pillow_N = DictGer.kissen_N ;
|
|
pilot_N = DictGer.lotse_N ;
|
|
pimp_N = DictGer.lude_N ;
|
|
pimpernel_N = DictGer.gauchheil_N ;
|
|
pimple_N = DictGer.pickel_N ;
|
|
pin_N = DictGer.bolzen_N ;
|
|
pinch_V = DictGer.kneifen_V ;
|
|
pinch_V2 = P.dirV2 (DictGer.kneifen_V) ;
|
|
pincushion_N = DictGer.nadelkissen_N ;
|
|
pine_N = DictGer.foehre_N ;
|
|
pink_N = DictGer.nelke_N ;
|
|
pinnacle_N = DictGer.gipfel_N ;
|
|
pioneer_N = DictGer.pionier_N ;
|
|
pious_A = DictGer.fromm_A ;
|
|
pipe_N = DictGer.floete_N ;
|
|
pipeline_N = DictGer.pipeline_N ;
|
|
pipette_N = DictGer.pipette_N ;
|
|
piquant_A = DictGer.pikant_A ;
|
|
piracy_N = DictGer.piraterie_N ;
|
|
pirate_N = DictGer.korsar_N ;
|
|
pistil_N = DictGer.stempel_N ;
|
|
pistol_N = DictGer.pistole_N ;
|
|
piston_N = DictGer.kolben_N ;
|
|
pit_N = DictGer.box_N ;
|
|
pitch_N = DictGer.abstand_N ;
|
|
pitcher_N = DictGer.krug_N ;
|
|
pitchfork_N = DictGer.heugabel_N ;
|
|
pittance_N = DictGer.almosen_N ;
|
|
pivotal_A = DictGer.ausschlaggebend_A ;
|
|
pixie_N = DictGer.kobold_N ;
|
|
placard_N = DictGer.plakat_N ;
|
|
place_N = DictGer.ort_N ;
|
|
placebo_N = DictGer.placebo_N ;
|
|
placid_A = DictGer.friedlich_A ;
|
|
plagiarism_N = DictGer.plagiat_N ;
|
|
plaice_N = DictGer.scholle_N ;
|
|
plain_A = DictGer.schlicht_A ;
|
|
plaintiff_N = DictGer.klaeger_N ;
|
|
plan_N = DictGer.plan_N ;
|
|
planet_N = LexiconGer.planet_N ;
|
|
planetarium_N = DictGer.planetarium_N ;
|
|
plank_N = DictGer.planke_N ;
|
|
plant_N = DictGer.anlage_N ;
|
|
plantain_N = DictGer.wegerich_N ;
|
|
plantation_N = DictGer.plantage_N ;
|
|
plaque_N = DictGer.plakette_N ;
|
|
plasma_N = DictGer.plasma_N ;
|
|
plaster_N = DictGer.gips_N ;
|
|
plasterer_N = DictGer.stuckateur_N ;
|
|
plastic_N = LexiconGer.plastic_N ;
|
|
plasticine_N = DictGer.knete_N ;
|
|
plate_N = DictGer.gang_N ;
|
|
platform_N = DictGer.bahnsteig_N ;
|
|
platitude_N = DictGer.plattituede_N ;
|
|
platonic_A = DictGer.platonisch_A ;
|
|
platoon_N = DictGer.kolonne_N ;
|
|
platter_N = DictGer.teller_N ;
|
|
platypus_N = DictGer.schnabeltier_N ;
|
|
play_N = DictGer.schauspiel_N ;
|
|
play_V = LexiconGer.play_V ;
|
|
play_V2 = LexiconGer.play_V2 ;
|
|
playboy_N = DictGer.playboy_N ;
|
|
player_N = DictGer.spieler_N ;
|
|
playground_N = DictGer.schulhof_N ;
|
|
playmate_N = DictGer.playmate_N ;
|
|
plaything_N = DictGer.spielball_N ;
|
|
plaza_N = DictGer.platz_N ;
|
|
plead_V = DictGer.plaedieren_V ;
|
|
plead_V2 = P.dirV2 (DictGer.plaedieren_V) ;
|
|
pleasant_A = DictGer.angenehm_A ;
|
|
pleased_A = DictGer.froh_A ;
|
|
pleasure_N = DictGer.freude_N ;
|
|
plebiscite_N = DictGer.plebiszit_N ;
|
|
pledge_V2 = P.dirV2 (DictGer.versprechen_V) ;
|
|
plenty_N = DictGer.fuelle_N ;
|
|
pleonasm_N = DictGer.pleonasmus_N ;
|
|
plethora_N = DictGer.fuelle_N ;
|
|
plinth_N = DictGer.sockel_N ;
|
|
plosive_N = DictGer.plosiv_N ;
|
|
plot_N = DictGer.handlung_N ;
|
|
plough_N = DictGer.pflug_N ;
|
|
plover_N = DictGer.regenpfeifer_N ;
|
|
pluck_V = DictGer.pfluecken_V ;
|
|
pluck_V2 = P.dirV2 (DictGer.pfluecken_V) ;
|
|
plucky_A = DictGer.beherzt_A ;
|
|
plug_N = DictGer.stecker_N ;
|
|
plum_N = DictGer.pflaume_N ;
|
|
plumage_N = DictGer.federkleid_N ;
|
|
plumber_N = DictGer.klempner_N ;
|
|
plumbing_N = DictGer.gedaerm_N ;
|
|
plunder_V = DictGer.pluendern_V ;
|
|
plunder_V2 = P.dirV2 (DictGer.pluendern_V) ;
|
|
plutocracy_N = DictGer.plutokratie_N ;
|
|
pneumatic_A = DictGer.pneumatisch_A ;
|
|
pneumonia_N = DictGer.lungenentzuendung_N ;
|
|
poach_V = DictGer.pochieren_V ;
|
|
poach_V2 = P.dirV2 (DictGer.pochieren_V) ;
|
|
poacher_N = DictGer.wilderer_N ;
|
|
pocket_N = DictGer.tasche_N ;
|
|
pod_N = DictGer.schote_N ;
|
|
poem_N = DictGer.dichtung_N ;
|
|
poet_N = DictGer.dichter_N ;
|
|
poetess_N = DictGer.dichterin_N ;
|
|
poinsettia_N = DictGer.weihnachtsstern_N ;
|
|
point_N = DictGer.punkt_N ;
|
|
pointer_N = DictGer.zeiger_N ;
|
|
pointless_A = DictGer.sinnlos_A ;
|
|
poison_N = DictGer.gift_N ;
|
|
poisonous_A = DictGer.giftig_A ;
|
|
poke_V = DictGer.schueren_V ;
|
|
poke_V2 = P.dirV2 (DictGer.schueren_V) ;
|
|
poker_N = DictGer.schuerhaken_N ;
|
|
polar_A = DictGer.polar_A ;
|
|
polarize_V2 = P.dirV2 (DictGer.polarisieren_V) ;
|
|
pole_N = DictGer.pol_N ;
|
|
polecat_N = DictGer.iltis_N ;
|
|
polemic_N = DictGer.polemik_N ;
|
|
policeman_N = LexiconGer.policeman_N ;
|
|
policewoman_N = DictGer.polizistin_N ;
|
|
policy_N = DictGer.politik_N ;
|
|
polish_N = DictGer.politur_N ;
|
|
polite_A = DictGer.hoeflich_A ;
|
|
politeness_N = DictGer.hoeflichkeit_N ;
|
|
political_A = DictGer.politisch_A ;
|
|
politician_N = DictGer.politiker_N ;
|
|
politics_N = DictGer.politik_N ;
|
|
polka_N = DictGer.polka_N ;
|
|
poll_N = DictGer.umfrage_N ;
|
|
pollen_N = DictGer.bluetenstaub_N ;
|
|
pollution_N = DictGer.umweltverschmutzung_N ;
|
|
poltergeist_N = DictGer.poltergeist_N ;
|
|
polygamous_A = DictGer.polygam_A ;
|
|
polyglot_A = DictGer.mehrsprachig_A ;
|
|
polygon_N = DictGer.polygon_N ;
|
|
polyp_N = DictGer.polyp_N ;
|
|
polytheistic_A = DictGer.polytheistisch_A ;
|
|
pomade_N = DictGer.pomade_N ;
|
|
pomegranate_N = DictGer.granatapfel_N ;
|
|
pomelo_N = DictGer.pampelmuse_N ;
|
|
pompous_A = DictGer.pompoes_A ;
|
|
pond_N = DictGer.teich_N ;
|
|
ponder_V = DictGer.ueberlegen_V ;
|
|
ponder_V2 = P.dirV2 (DictGer.ueberlegen_V) ;
|
|
pontoon_N = DictGer.ponton_N ;
|
|
ponytail_N = DictGer.pferdeschwanz_N ;
|
|
poodle_N = DictGer.pudel_N ;
|
|
pool_N = DictGer.becken_N ;
|
|
poor_A = DictGer.arm_A ;
|
|
poorhouse_N = DictGer.armenhaus_N ;
|
|
pope_N = DictGer.papst_N ;
|
|
poplar_N = DictGer.pappel_N ;
|
|
populace_N = DictGer.bevoelkerung_N ;
|
|
popular_A = DictGer.beliebt_A ;
|
|
population_N = DictGer.bevoelkerung_N ;
|
|
porcelain_N = DictGer.porzellan_N ;
|
|
porcupine_N = DictGer.urson_N ;
|
|
pore_N = DictGer.pore_N ;
|
|
porn_N = DictGer.porno_N ;
|
|
pornography_N = DictGer.pornografie_N ;
|
|
port_N = DictGer.hafen_N ;
|
|
portable_A = DictGer.portabel_A ;
|
|
portal_N = DictGer.portal_N ;
|
|
portcullis_N = DictGer.fallgatter_N ;
|
|
portfolio_N = DictGer.mappe_N ;
|
|
porthole_N = DictGer.bullauge_N ;
|
|
portion_N = DictGer.teil_N ;
|
|
portmanteau_N = DictGer.koffer_N ;
|
|
portray_V2 = P.dirV2 (DictGer.portraetieren_V) ;
|
|
portrayal_N = DictGer.abbild_N ;
|
|
portuguese_A = DictGer.portugiesisch_A ;
|
|
pose_V = DictGer.legen_4_V ;
|
|
pose_V2 = P.dirV2 (DictGer.legen_4_V) ;
|
|
position_N = DictGer.position_N ;
|
|
positive_A = DictGer.positiv_A ;
|
|
posse_N = DictGer.bande_N ;
|
|
possess_V2 = P.dirV2 (DictGer.besitzen_V) ;
|
|
possessor_N = DictGer.besitzer_N ;
|
|
possibility_N = DictGer.moeglichkeit_N ;
|
|
possible_A = DictGer.moeglich_A ;
|
|
possum_N = DictGer.possum_N ;
|
|
post_N = DictGer.beitrag_N ;
|
|
postal_A = DictGer.postalisch_A ;
|
|
postcard_N = DictGer.postkarte_N ;
|
|
postcode_N = DictGer.postleitzahl_N ;
|
|
poster_N = DictGer.anschlag_N ;
|
|
postern_N = DictGer.hintertuer_N ;
|
|
posthumous_A = DictGer.posthum_A ;
|
|
postpone_V2 = P.dirV2 (DictGer.verschieben_V) ;
|
|
postulate_N = DictGer.postulat_N ;
|
|
posture_N = DictGer.haltung_N ;
|
|
pot_N = DictGer.einsatz_N ;
|
|
potable_A = DictGer.trinkbar_A ;
|
|
potash_N = DictGer.pottasche_N ;
|
|
potato_N = DictGer.erdapfel_N ;
|
|
potbellied_A = DictGer.dickbaeuchig_A ;
|
|
potbelly_N = DictGer.wampe_N ;
|
|
potential_N = DictGer.potential_N ;
|
|
pothead_N = DictGer.kiffer_N ;
|
|
pothole_N = DictGer.schlagloch_N ;
|
|
potion_N = DictGer.trank_N ;
|
|
potpourri_N = DictGer.potpourri_N ;
|
|
potsherd_N = DictGer.scherbe_N ;
|
|
potter_N = DictGer.toepfer_N ;
|
|
pouch_N = DictGer.beutel_N ;
|
|
pound_N = DictGer.pfund_N ;
|
|
pour_V = DictGer.giessen_V ;
|
|
pour_V2 = P.dirV2 (DictGer.giessen_V) ;
|
|
powder_N = DictGer.puder_N ;
|
|
power_N = DictGer.energie__N ;
|
|
powerless_A = DictGer.machtlos_A ;
|
|
practice_N = DictGer.praxis_N ;
|
|
pragmatic_A = DictGer.pragmatisch_A ;
|
|
prairie_N = DictGer.praerie_N ;
|
|
praise_N = DictGer.lob_N ;
|
|
pram_N = DictGer.kinderwagen_N ;
|
|
prank_N = DictGer.streich_N ;
|
|
prawn_N = DictGer.garnele_N ;
|
|
pray_V = DictGer.beten_2_V ;
|
|
pray_V2 = P.dirV2 (DictGer.beten_2_V) ;
|
|
prayer_N = DictGer.gebet_N ;
|
|
preach_V = DictGer.predigen_V ;
|
|
preach_V2 = P.dirV2 (DictGer.predigen_V) ;
|
|
preacher_N = DictGer.prediger__N ;
|
|
preamble_N = DictGer.praeambel_N ;
|
|
precarious_A = DictGer.prekaer_A ;
|
|
precept_N = DictGer.gebot_N ;
|
|
precipice_N = DictGer.abgrund_N ;
|
|
precipitation_N = DictGer.niederschlag_N ;
|
|
precipitous_A = DictGer.abrupt_A ;
|
|
precise_A = DictGer.exakt_A ;
|
|
precondition_N = DictGer.vorbedingung_N ;
|
|
precursor_N = DictGer.edukt_N ;
|
|
predator_N = DictGer.raubtier_N ;
|
|
predecessor_N = DictGer.vorgaenger_N ;
|
|
predicament_N = DictGer.kategorie_N ;
|
|
predicate_N = DictGer.praedikat_N ;
|
|
predict_V2 = P.dirV2 (DictGer.prophezeien_V) ;
|
|
prediction_N = DictGer.prophezeiung_N ;
|
|
prefer_V2 = P.dirV2 (DictGer.bevorzugen_V) ;
|
|
prefix_N = DictGer.praefix_N ;
|
|
pregnancy_N = DictGer.schwangerschaft_N ;
|
|
pregnant_A = DictGer.bedeutungsvoll_A ;
|
|
prehistoric_A = DictGer.praehistorisch_A ;
|
|
prejudice_N = DictGer.vorurteil_N ;
|
|
prejudicial_A = DictGer.abtraeglich_A ;
|
|
preliminary_A = DictGer.vorlaeufig_A ;
|
|
prelude_N = DictGer.praeludium_N ;
|
|
preparation_N = DictGer.vorbereitung_N ;
|
|
preposition_N = DictGer.praeposition_N ;
|
|
preposterous_A = DictGer.absurd_A ;
|
|
prepuce_N = DictGer.vorhaut_N ;
|
|
prerogative_N = DictGer.praerogative_N ;
|
|
prescribe_V = DictGer.verordnen_V ;
|
|
prescribe_V2 = P.dirV2 (DictGer.verordnen_V) ;
|
|
prescription_N = DictGer.rezept_N ;
|
|
present_A = DictGer.anwesend_A ;
|
|
presentation_N = DictGer.praesentation_N ;
|
|
president_N = DictGer.praesident_N ;
|
|
press_N = DictGer.presse_N ;
|
|
pressure_N = DictGer.pressure_N ;
|
|
prestigious_A = DictGer.prestigetraechtig_A ;
|
|
presume_V = DictGer.mutmassen_V ;
|
|
presume_V2 = P.dirV2 (DictGer.mutmassen_V) ;
|
|
presumption_N = DictGer.annahme_N ;
|
|
presumptuous_A = DictGer.anmassend_A ;
|
|
presupposition_N = DictGer.annahme_N ;
|
|
pretender_N = DictGer.angeber_N ;
|
|
pretentious_A = DictGer.praetentioes_A ;
|
|
pretext_N = DictGer.vorwand_N ;
|
|
pretty_A = DictGer.huebsch_A ;
|
|
prevarication_N = DictGer.ausflucht_N ;
|
|
prevent_V2 = P.dirV2 (DictGer.verhindern_V) ;
|
|
prevention_N = DictGer.praevention_N ;
|
|
preventive_A = DictGer.praeventiv_A ;
|
|
price_N = DictGer.preis_N ;
|
|
prick_N = DictGer.pimmel_N ;
|
|
pride_N = DictGer.rudel_N ;
|
|
priest_N = LexiconGer.priest_N ;
|
|
primary_A = DictGer.primaer_A ;
|
|
primate_N = DictGer.primat_N ;
|
|
primer_N = DictGer.fibel_N ;
|
|
primordial_A = DictGer.urspruenglich_A ;
|
|
prince_N = DictGer.fuerst_N ;
|
|
princess_N = DictGer.prinzessin_N ;
|
|
principal_A = DictGer.hauptsaechlich_A ;
|
|
principality_N = DictGer.fuerstentum_N ;
|
|
printer_N = DictGer.drucker_N ;
|
|
priority_N = DictGer.prioritaet_N ;
|
|
prism_N = DictGer.prisma_N ;
|
|
prison_N = DictGer.gefangenschaft_N ;
|
|
privacy_N = DictGer.privatsphaere_N ;
|
|
private_A = DictGer.privat_A ;
|
|
privatize_V2 = P.dirV2 (DictGer.privatisieren_V) ;
|
|
privet_N = DictGer.liguster_N ;
|
|
privy_A = DictGer.geheim_A ;
|
|
prize_N = DictGer.preis_N ;
|
|
probability_N = DictGer.wahrscheinlichkeit_N ;
|
|
probable_A = DictGer.wahrscheinlich_A ;
|
|
probation_N = DictGer.bewaehrung_N ;
|
|
problem_N = DictGer.problem_N ;
|
|
problematic_A = DictGer.problematisch_A ;
|
|
proboscis_N = DictGer.ruessel_N ;
|
|
procedure_N = DictGer.prozedere_N ;
|
|
process_N = DictGer.prozess_N ;
|
|
processor_N = DictGer.prozessor_N ;
|
|
proclivity_N = DictGer.hang_N ;
|
|
procrastinate_V = DictGer.prokrastinieren_V ;
|
|
procrastination_N = DictGer.aufschub_N ;
|
|
procure_V2 = P.dirV2 (DictGer.beschaffen_V) ;
|
|
procurement_N = DictGer.beschaffung_N ;
|
|
prodigal_A = DictGer.verschwenderisch_A ;
|
|
prodigious_A = DictGer.gewaltig_A ;
|
|
produce_V = DictGer.produzieren_V ;
|
|
produce_V2 = P.dirV2 (DictGer.produzieren_V) ;
|
|
producer_N = DictGer.hersteller_N ;
|
|
product_N = DictGer.produkt_N ;
|
|
production_N = DictGer.herstellung_N ;
|
|
professional_N = DictGer.profi_N ;
|
|
professor_N = DictGer.professor_N ;
|
|
proficient_A = DictGer.befaehigt_A ;
|
|
profit_N = DictGer.gewinn_N ;
|
|
profitable_A = DictGer.lukrativ_A ;
|
|
profligacy_N = DictGer.verschwendung_N ;
|
|
profound_A = DictGer.profund_A ;
|
|
progenitor_N = DictGer.erzeuger_N ;
|
|
prognosticate_V2 = P.dirV2 (DictGer.prognostizieren_V) ;
|
|
program_N = DictGer.programm_N ;
|
|
progress_N = DictGer.fortschritt_N ;
|
|
progressive_A = DictGer.progressiv_A ;
|
|
prohibit_V = DictGer.verbieten_V ;
|
|
prohibit_V2 = P.dirV2 (DictGer.verbieten_V) ;
|
|
prohibition_N = DictGer.verbot_N ;
|
|
project_N = DictGer.projekt_N ;
|
|
projection_N = DictGer.prognose_N ;
|
|
projector_N = DictGer.projektor_N ;
|
|
proliferation_N = DictGer.verbreitung_N ;
|
|
prolific_A = DictGer.fruchtbar_A ;
|
|
prolix_A = DictGer.weitschweifig_A ;
|
|
prom_N = DictGer.ball_N ;
|
|
promenade_N = DictGer.promenade_N ;
|
|
prominent_A = DictGer.prominent_A ;
|
|
promiscuous_A = DictGer.freizuegig_A ;
|
|
promise_N = DictGer.versprechen_N ;
|
|
promote_V = DictGer.befoerdern_V ;
|
|
promote_V2 = P.dirV2 (DictGer.befoerdern_V) ;
|
|
promotion_N = DictGer.befoerderung_N ;
|
|
pronounce_V = DictGer.verkuenden_V ;
|
|
pronounce_V2 = P.dirV2 (DictGer.verkuenden_V) ;
|
|
pronunciation_N = DictGer.aussprache_N ;
|
|
proof_N = DictGer.beweis_N ;
|
|
prop_N = DictGer.stuetze_N ;
|
|
propagate_V = DictGer.verbreiten_V ;
|
|
propagate_V2 = P.dirV2 (DictGer.verbreiten_V) ;
|
|
propeller_N = DictGer.propeller_N ;
|
|
propensity_N = DictGer.neigung_N ;
|
|
proper_A = DictGer.angemessen_A ;
|
|
property_N = DictGer.anwesen_N ;
|
|
prophecy_N = DictGer.prophezeiung_N ;
|
|
prophesy_V = DictGer.prophezeien_V ;
|
|
prophesy_V2 = P.dirV2 (DictGer.prophezeien_V) ;
|
|
prophet_N = DictGer.prophet_N ;
|
|
proponent_N = DictGer.befuerworter_N ;
|
|
proportion_N = DictGer.proportion_N ;
|
|
proportional_A = DictGer.proportional_A ;
|
|
proposal_N = DictGer.vorschlag_N ;
|
|
proposition_N = DictGer.satz_N ;
|
|
proprietary_A = DictGer.proprietaer_A ;
|
|
prorogue_V2 = P.dirV2 (DictGer.verlaengern_V) ;
|
|
prosaic_A = DictGer.prosaisch_A ;
|
|
proscribe_V2 = P.dirV2 (DictGer.verbieten_V) ;
|
|
prose_N = DictGer.prosa_N ;
|
|
prosecutor_N = DictGer.staatsanwalt_N ;
|
|
prosody_N = DictGer.prosodie_N ;
|
|
prospective_A = DictGer.voraussichtlich_A ;
|
|
prospector_N = DictGer.goldsucher_N ;
|
|
prostate_N = DictGer.prostata_N ;
|
|
prostitute_N = DictGer.dirne_N ;
|
|
protagonist_N = DictGer.held_N ;
|
|
protect_V = DictGer.schuetzen_V ;
|
|
protect_V2 = P.dirV2 (DictGer.schuetzen_V) ;
|
|
protein_N = DictGer.protein_N ;
|
|
protester_N = DictGer.protestant_N ;
|
|
proton_N = DictGer.proton_N ;
|
|
prototype_N = DictGer.prototyp_N ;
|
|
prove_V = DictGer.beweisen_V ;
|
|
prove_V2 = P.dirV2 (DictGer.beweisen_V) ;
|
|
provide_V = DictGer.versehen_V ;
|
|
provide_V2 = P.dirV2 (DictGer.versehen_V) ;
|
|
providence_N = DictGer.vorsorge_N ;
|
|
province_N = DictGer.provinz_N ;
|
|
provisional_A = DictGer.provisorisch_A ;
|
|
provocation_N = DictGer.provokation_N ;
|
|
provocative_A = DictGer.provokant_A ;
|
|
provoke_V2 = P.dirV2 (DictGer.provozieren_V) ;
|
|
prudish_A = DictGer.pruede_A ;
|
|
prussian_A = DictGer.preussisch_A ;
|
|
pry_V = DictGer.schnueffeln_V ;
|
|
pry_V2 = P.dirV2 (DictGer.schnueffeln_V) ;
|
|
psalm_N = DictGer.psalm_N ;
|
|
pseudonym_N = DictGer.pseudonym_N ;
|
|
psychedelic_A = DictGer.psychedelisch_A ;
|
|
psychiatrist_N = DictGer.psychiater_N ;
|
|
psychiatry_N = DictGer.psychiatrie_N ;
|
|
psychoanalysis_N = DictGer.psychoanalyse_N ;
|
|
psychologist_N = DictGer.psychologe_N ;
|
|
psychopath_N = DictGer.psychopath_N ;
|
|
psychosis_N = DictGer.psychose_N ;
|
|
psychosomatic_A = DictGer.psychosomatisch_A ;
|
|
pub_N = DictGer.kneipe_N ;
|
|
public_A = DictGer.oeffentlich_A ;
|
|
publication_N = DictGer.veroeffentlichung_N ;
|
|
publicity_N = DictGer.werbung_N ;
|
|
publish_V = DictGer.publizieren_V ;
|
|
publish_V2 = P.dirV2 (DictGer.publizieren_V) ;
|
|
publisher_N = DictGer.herausgeber_N ;
|
|
puck_N = DictGer.puck_N ;
|
|
pudding_N = DictGer.blutwurst_N ;
|
|
puddle_N = DictGer.lache_N ;
|
|
pugnacious_A = DictGer.streitsuechtig_A ;
|
|
pull_V = DictGer.ziehen_7_V ;
|
|
pull_V2 = LexiconGer.pull_V2 ;
|
|
pulley_N = DictGer.rolle_N ;
|
|
pullover_N = DictGer.pullover_N ;
|
|
pulpit_N = DictGer.kanzel_N ;
|
|
pulsar_N = DictGer.pulsar_N ;
|
|
pulsate_V = DictGer.pulsieren_V ;
|
|
pulsate_V2 = P.dirV2 (DictGer.pulsieren_V) ;
|
|
pulse_N = DictGer.puls_N ;
|
|
puma_N = DictGer.puma_N ;
|
|
pumice_N = DictGer.bims_N ;
|
|
pump_N = DictGer.pumpe_N ;
|
|
pumpkin_N = DictGer.kuerbis_N ;
|
|
pun_N = DictGer.wortspiel_N ;
|
|
punch_N = DictGer.bowle_N ;
|
|
punchbowl_N = DictGer.bowle_N ;
|
|
punctual_A = DictGer.puenktlich_A ;
|
|
punctuation_N = DictGer.satzzeichen_N ;
|
|
punish_V2 = P.dirV2 (DictGer.bestrafen_V) ;
|
|
punishable_A = DictGer.strafbar_A ;
|
|
punishment_N = DictGer.bestrafung_N ;
|
|
punk_N = DictGer.punk_N ;
|
|
punt_N = DictGer.stocherkahn_N ;
|
|
pupa_N = DictGer.puppe_N ;
|
|
pupil_N = DictGer.pupille_N ;
|
|
puppet_N = DictGer.marionette_N ;
|
|
puppy_N = DictGer.welpe_N ;
|
|
purchase_N = DictGer.anschaffung_N ;
|
|
pure_A = DictGer.pur_A ;
|
|
puree_N = DictGer.pueree_N ;
|
|
purgatory_N = DictGer.purgatorium_N ;
|
|
purification_N = DictGer.reinigung_N ;
|
|
purify_V2 = P.dirV2 (DictGer.reinigen_V) ;
|
|
purloin_V2 = P.dirV2 (DictGer.entwenden_V) ;
|
|
purpose_N = DictGer.absicht_N ;
|
|
purr_V = DictGer.schnurren_V ;
|
|
purr_V2 = P.dirV2 (DictGer.schnurren_V) ;
|
|
purse_N = DictGer.geldbeutel_N ;
|
|
pursue_V = DictGer.verfolgen_V ;
|
|
pursue_V2 = P.dirV2 (DictGer.verfolgen_V) ;
|
|
purview_N = DictGer.bereich_N ;
|
|
push_V = DictGer.draengen_5_V ;
|
|
push_V2 = LexiconGer.push_V2 ;
|
|
put_V = DictGer.legen_4_V ;
|
|
put_V2 = LexiconGer.put_V2 ;
|
|
putative_A = DictGer.mutmasslich_A ;
|
|
putsch_N = DictGer.putsch_N ;
|
|
puzzle_N = DictGer.puzzle_N ;
|
|
pyramid_N = DictGer.pyramide_N ;
|
|
pyre_N = DictGer.scheiterhaufen_N ;
|
|
python_N = DictGer.python_N ;
|
|
quack_N = DictGer.quacksalber_N ;
|
|
quackery_N = DictGer.quacksalberei_N ;
|
|
quadrangle_N = DictGer.viereck_N ;
|
|
quadratic_A = DictGer.quadratisch_A ;
|
|
quadrilateral_N = DictGer.viereck_N ;
|
|
quadrille_N = DictGer.quadrille_N ;
|
|
quadrillion_N = DictGer.quadrillion_N ;
|
|
quagmire_N = DictGer.sumpf_N ;
|
|
qualification_N = DictGer.qualifikation_N ;
|
|
qualify_V = DictGer.qualifizieren_V ;
|
|
qualify_V2 = P.dirV2 (DictGer.qualifizieren_V) ;
|
|
qualitative_A = DictGer.qualitativ_A ;
|
|
quality_N = DictGer.eigenschaft_N ;
|
|
quandary_N = DictGer.zwickmuehle_N ;
|
|
quantitative_A = DictGer.quantitativ_A ;
|
|
quantity_N = DictGer.menge_N ;
|
|
quantum_N = DictGer.minimum_N ;
|
|
quarantine_N = DictGer.quarantaene_N ;
|
|
quarrel_N = DictGer.streit_N ;
|
|
quarry_N = DictGer.steinbruch_N ;
|
|
quarterfinal_N = DictGer.viertelfinale_N ;
|
|
quartet_N = DictGer.quartett_N ;
|
|
quartz_N = DictGer.quarz_N ;
|
|
quasar_N = DictGer.quasar_N ;
|
|
quay_N = DictGer.kai_N ;
|
|
queasy_A = DictGer.uebel_A ;
|
|
queen_N = LexiconGer.queen_N ;
|
|
queer_A = DictGer.schwul_A ;
|
|
quench_V2 = P.dirV2 (DictGer.loeschen_5_V) ;
|
|
query_N = DictGer.abfrage_N ;
|
|
quest_N = DictGer.suche_N ;
|
|
question_N = LexiconGer.question_N ;
|
|
questionable_A = DictGer.fragwuerdig_A ;
|
|
queue_N = DictGer.reihe_N ;
|
|
quibble_N = DictGer.haarspalterei_N ;
|
|
quiche_N = DictGer.quiche_N ;
|
|
quick_A = DictGer.geschwind_A ;
|
|
quickie_N = DictGer.quickie_N ;
|
|
quiescent_A = DictGer.ruhig_A ;
|
|
quiet_A = DictGer.leise_A ;
|
|
quill_N = DictGer.kiel_N ;
|
|
quince_N = DictGer.quitte_N ;
|
|
quintet_N = DictGer.quintett_N ;
|
|
quisling_N = DictGer.verraeter_N ;
|
|
quit_V = DictGer.verlassen_V ;
|
|
quit_V2 = P.dirV2 (DictGer.verlassen_V) ;
|
|
quiver_N = DictGer.koecher_N ;
|
|
quorum_N = DictGer.quorum_N ;
|
|
quota_N = DictGer.quote_N ;
|
|
quotation_N = DictGer.angebot_N ;
|
|
quote_V = DictGer.zitieren_V ;
|
|
quote_V2 = P.dirV2 (DictGer.zitieren_V) ;
|
|
quotidian_A = DictGer.alltaeglich_A ;
|
|
quotient_N = DictGer.quotient_N ;
|
|
rabbi_N = DictGer.rabbiner_N ;
|
|
rabbinical_A = DictGer.rabbinisch_A ;
|
|
rabbit_N = DictGer.kaninchen_N ;
|
|
rabid_A = DictGer.fanatisch_A ;
|
|
raccoon_N = DictGer.waschbaer_N ;
|
|
race_N = DictGer.geschlecht_N ;
|
|
racehorse_N = DictGer.rennpferd_N ;
|
|
racist_N = DictGer.rassist_N ;
|
|
racket_N = DictGer.krach__N ;
|
|
radiation_N = DictGer.radiation_N ;
|
|
radiator_N = DictGer.kuehler_N ;
|
|
radical_A = DictGer.krass_A ;
|
|
radio_N = LexiconGer.radio_N ;
|
|
radioactive_A = DictGer.radioaktiv_A ;
|
|
radish_N = DictGer.radieschen_N ;
|
|
radius_N = DictGer.radius_N ;
|
|
raft_N = DictGer.floss_N ;
|
|
rafter_N = DictGer.sparren_N ;
|
|
rag_N = DictGer.fetzen_N ;
|
|
ragout_N = DictGer.ragout_N ;
|
|
raid_N = DictGer.razzia_N ;
|
|
rail_N = DictGer.gelaender_N ;
|
|
railroad_N = DictGer.eisenbahn__N ;
|
|
railway_N = DictGer.bahn_N ;
|
|
rain_N = LexiconGer.rain_N ;
|
|
rainbow_N = DictGer.regenbogen_N ;
|
|
raincoat_N = DictGer.regenmantel_N ;
|
|
raindrop_N = DictGer.regentropfen_N ;
|
|
rainfall_N = DictGer.niederschlag_N ;
|
|
rainy_A = DictGer.regnerisch_A ;
|
|
raise_V2 = P.dirV2 (DictGer.heben_5_V) ;
|
|
raisin_N = DictGer.rosine_N ;
|
|
rake_N = DictGer.harke_N ;
|
|
rally_N = DictGer.kundgebung_N ;
|
|
rambunctious_A = DictGer.wild_A ;
|
|
ramification_N = DictGer.auswirkung_N ;
|
|
ramify_V = DictGer.ramifizieren_V ;
|
|
ramify_V2 = P.dirV2 (DictGer.ramifizieren_V) ;
|
|
ramp_N = DictGer.rampe_N ;
|
|
rampart_N = DictGer.wall_N ;
|
|
rancid_A = DictGer.ranzig_A ;
|
|
rancorous_A = DictGer.nachtragend_A ;
|
|
rand_N = DictGer.rand_N ;
|
|
range_N = DictGer.reichweite_N ;
|
|
rank_A = DictGer.ekelhaft_A ;
|
|
ransack_V2 = P.dirV2 (DictGer.pluendern_V) ;
|
|
ransom_N = DictGer.loesegeld_N ;
|
|
rape_N = DictGer.vergewaltigung_N ;
|
|
rapid_A = DictGer.schnell_A ;
|
|
rapier_N = DictGer.florett_N ;
|
|
rapine_N = DictGer.raub_N ;
|
|
rapprochement_N = DictGer.annaeherung_N ;
|
|
rare_A = DictGer.blutig_A ;
|
|
rascal_N = DictGer.bengel_N ;
|
|
rasp_N = DictGer.raspel_N ;
|
|
raspberry_N = DictGer.himbeere_N ;
|
|
rat_N = DictGer.ratte_N ;
|
|
ratchet_N = DictGer.ratsche_N ;
|
|
rate_N = DictGer.rate_N ;
|
|
ratification_N = DictGer.bestaetigung_N ;
|
|
ration_N = DictGer.ration_N ;
|
|
rational_A = DictGer.rational_A ;
|
|
rationale_N = DictGer.argumentation_N ;
|
|
rattle_N = DictGer.rassel_N ;
|
|
rattlesnake_N = DictGer.klapperschlange_N ;
|
|
raven_N = DictGer.kolkrabe_N ;
|
|
ravine_N = DictGer.schlucht_N ;
|
|
raw_A = DictGer.roh_A ;
|
|
ray_N = DictGer.rochen_N ;
|
|
reach_V = DictGer.begreifen_V ;
|
|
reach_V2 = P.dirV2 (DictGer.begreifen_V) ;
|
|
reaction_N = DictGer.reaktion_N ;
|
|
reactor_N = DictGer.atomreaktor_N ;
|
|
read_V2 = LexiconGer.read_V2 ;
|
|
reader_N = DictGer.leser_N ;
|
|
readmission_N = DictGer.wiederaufnahme_N ;
|
|
ready_A = LexiconGer.ready_A ;
|
|
realism_N = DictGer.realismus_N ;
|
|
realistic_A = DictGer.realistisch_A ;
|
|
reality_N = DictGer.realitaet_N ;
|
|
realm_N = DictGer.koenigreich_N ;
|
|
reap_V = DictGer.ernten_9_V ;
|
|
reap_V2 = P.dirV2 (DictGer.ernten_9_V) ;
|
|
rearguard_N = DictGer.nachhut_N ;
|
|
reason_N = LexiconGer.reason_N ;
|
|
reasonable_A = DictGer.anstaendig_A ;
|
|
rebel_N = DictGer.aufruehrer_N ;
|
|
rebirth_N = DictGer.wiedergeburt_N ;
|
|
rebuke_N = DictGer.tadel_N ;
|
|
recall_V2 = P.dirV2 (DictGer.gedenken_V) ;
|
|
receipt_N = DictGer.empfang_N ;
|
|
receive_V = DictGer.bekommen_8_V ;
|
|
receive_V2 = P.dirV2 (DictGer.bekommen_8_V) ;
|
|
receiver_N = DictGer.empfaenger_N ;
|
|
recent_A = DictGer.neu_A ;
|
|
reception_N = DictGer.empfang_N ;
|
|
recess_N = DictGer.nische_N ;
|
|
recession_N = DictGer.rezession_N ;
|
|
recipe_N = DictGer.kochrezept_N ;
|
|
recipient_N = DictGer.empfaenger_N ;
|
|
reciprocal_A = DictGer.entgegengesetzt_A ;
|
|
reciprocate_V = DictGer.erwidern_V ;
|
|
reciprocate_V2 = P.dirV2 (DictGer.erwidern_V) ;
|
|
recitation_N = DictGer.rezitation_N ;
|
|
reckless_A = DictGer.ruecksichtslos_A ;
|
|
recognition_N = DictGer.anerkennung_N ;
|
|
recognize_V2 = P.dirV2 (DictGer.erkennen_2_V) ;
|
|
recommend_V2 = P.dirV2 (DictGer.empfehlen_V) ;
|
|
recommendation_N = DictGer.empfehlung_N ;
|
|
reconciliation_N = DictGer.aussoehnung_N ;
|
|
reconnaissance_N = DictGer.aufklaerung_N ;
|
|
reconsider_V2 = P.dirV2 (DictGer.ueberdenken_V) ;
|
|
reconstruction_N = DictGer.rekonstruktion_N ;
|
|
record_N = DictGer.aufnahme_N ;
|
|
recorder_N = DictGer.blockfloete_N ;
|
|
recovery_N = DictGer.genesung_N ;
|
|
recreation_N = DictGer.unterhaltung_N ;
|
|
recruit_N = DictGer.rekrut_N ;
|
|
rectal_A = DictGer.rektal_A ;
|
|
rectangle_N = DictGer.rechteck_N ;
|
|
rectangular_A = DictGer.rechteckig_A ;
|
|
rectify_V2 = P.dirV2 (DictGer.korrigieren_V) ;
|
|
rector_N = DictGer.rektor_N ;
|
|
rectum_N = DictGer.rektum_N ;
|
|
recurrence_N = DictGer.rekurrenz_N ;
|
|
recurrent_A = DictGer.wiederholt_A ;
|
|
red_A = LexiconGer.red_A ;
|
|
reddish_A = DictGer.roetlich_A ;
|
|
redeem_V2 = P.dirV2 (DictGer.befreien_V) ;
|
|
redemption_N = DictGer.erloesung_N ;
|
|
reduction_N = DictGer.reduktion_N ;
|
|
redundancy_N = DictGer.redundanz_N ;
|
|
redundant_A = DictGer.redundant_A ;
|
|
reed_N = DictGer.schilf_N ;
|
|
reefer_N = DictGer.joint_N ;
|
|
reek_N = DictGer.dampf_N ;
|
|
reel_N = DictGer.spule_N ;
|
|
refer_V = DictGer.verweisen_V ;
|
|
refer_V2 = P.dirV2 (DictGer.verweisen_V) ;
|
|
referee_N = DictGer.lektor_N ;
|
|
reference_N = DictGer.quelle_N ;
|
|
referendum_N = DictGer.referendum_N ;
|
|
refinery_N = DictGer.raffinerie_N ;
|
|
reflect_V = DictGer.reflektieren_V ;
|
|
reflect_V2 = P.dirV2 (DictGer.reflektieren_V) ;
|
|
reflection_N = DictGer.abbild_N ;
|
|
reflex_N = DictGer.reflex_N ;
|
|
reflexive_A = DictGer.reflexiv_A ;
|
|
reform_N = DictGer.reform_N ;
|
|
reformer_N = DictGer.reformator_N ;
|
|
refract_V2 = P.dirV2 (DictGer.brechen_8_V) ;
|
|
refraction_N = DictGer.brechung_N ;
|
|
refreshing_A = DictGer.erfrischend_A ;
|
|
refrigerate_V2 = P.dirV2 (DictGer.kuehlen_2_V) ;
|
|
refuge_N = DictGer.herberge_N ;
|
|
refugee_N = DictGer.asylant_N ;
|
|
refute_V2 = P.dirV2 (DictGer.widerlegen_V) ;
|
|
regenerate_V = DictGer.erneuern_V ;
|
|
regenerate_V2 = P.dirV2 (DictGer.erneuern_V) ;
|
|
regiment_N = DictGer.regiment_N ;
|
|
region_N = DictGer.gegend_N ;
|
|
regional_A = DictGer.regional_A ;
|
|
register_N = DictGer.register_N ;
|
|
registration_N = DictGer.anmeldung_N ;
|
|
regret_V2 = P.dirV2 (DictGer.bedauern_V) ;
|
|
regrettable_A = DictGer.bedauerlich_A ;
|
|
regular_A = DictGer.gewoehnlich_A ;
|
|
regulate_V2 = P.dirV2 (DictGer.regeln_V) ;
|
|
regulation_N = DictGer.regelung_N ;
|
|
rehabilitate_V2 = P.dirV2 (DictGer.rehabilitieren_V) ;
|
|
rehabilitation_N = DictGer.rehabilitation_N ;
|
|
rehearsal_N = DictGer.probe_N ;
|
|
rehearse_V = DictGer.erzaehlen_V ;
|
|
rehearse_V2 = P.dirV2 (DictGer.erzaehlen_V) ;
|
|
reign_N = DictGer.herrschaft_N ;
|
|
reimburse_V2 = P.dirV2 (DictGer.erstatten_V) ;
|
|
rein_N = DictGer.zuegel_N ;
|
|
reincarnation_N = DictGer.reinkarnation_N ;
|
|
reindeer_N = DictGer.rentier_N ;
|
|
reinforce_V2 = P.dirV2 (DictGer.verstaerken_V) ;
|
|
reinforcement_N = DictGer.verstaerkung_N ;
|
|
reject_V2 = P.dirV2 (DictGer.verwerfen_V) ;
|
|
rejoice_V = DictGer.erfreuen_V ;
|
|
rejoice_V2 = P.dirV2 (DictGer.erfreuen_V) ;
|
|
rejuvenate_V = DictGer.verjuengen_V ;
|
|
rejuvenate_V2 = P.dirV2 (DictGer.verjuengen_V) ;
|
|
relation_N = DictGer.beziehung_N ;
|
|
relationship_N = DictGer.beziehung_N ;
|
|
relative_A = DictGer.relativ_A ;
|
|
relax_V = DictGer.entspannen_V ;
|
|
relax_V2 = P.dirV2 (DictGer.entspannen_V) ;
|
|
relay_N = DictGer.relais_N ;
|
|
release_N = DictGer.version_N ;
|
|
relentless_A = DictGer.unnachgiebig_A ;
|
|
relevance_N = DictGer.aktualitaet_N ;
|
|
relevant_A = DictGer.relevant_A ;
|
|
reliable_A = DictGer.verlaesslich_A ;
|
|
relic_N = DictGer.relikt_N ;
|
|
relief_N = DictGer.entlastung_N ;
|
|
religion_N = LexiconGer.religion_N ;
|
|
religious_A = DictGer.religioes_A ;
|
|
relinquish_V2 = P.dirV2 (DictGer.verlassen_V) ;
|
|
relocate_V = DictGer.umziehen_V ;
|
|
relocate_V2 = P.dirV2 (DictGer.umziehen_V) ;
|
|
remainder_N = DictGer.rest_N ;
|
|
remark_N = DictGer.bemerkung_N ;
|
|
remedy_N = DictGer.heilmittel_N ;
|
|
remind_V2 = P.dirV2 (DictGer.erinnern_V) ;
|
|
reminder_N = DictGer.gedaechtnisstuetze_N ;
|
|
reminiscence_N = DictGer.reminiszenz_N ;
|
|
remittance_N = DictGer.ueberweisung_N ;
|
|
remnant_N = DictGer.rest_N ;
|
|
remote_A = DictGer.entfernt_A ;
|
|
removal_N = DictGer.entlassung_N ;
|
|
remove_V = DictGer.entfernen_V ;
|
|
remove_V2 = P.dirV2 (DictGer.entfernen_V) ;
|
|
remuneration_N = DictGer.belohnung_N ;
|
|
renal_A = DictGer.renal_A ;
|
|
rendezvous_N = DictGer.rendezvous_N ;
|
|
renegade_N = DictGer.renegat_N ;
|
|
renew_V2 = P.dirV2 (DictGer.erneuern_V) ;
|
|
renewable_A = DictGer.erneuerbar_A ;
|
|
rennet_N = DictGer.lab_N ;
|
|
renovate_V2 = P.dirV2 (DictGer.erneuern_V) ;
|
|
renovation_N = DictGer.renovierung_N ;
|
|
renown_N = DictGer.ansehen_N ;
|
|
renowned_A = DictGer.beruehmt_A ;
|
|
rent_N = DictGer.miete_N ;
|
|
repair_N = DictGer.ausbesserung_N ;
|
|
repatriation_N = DictGer.repatriierung_N ;
|
|
repeat_V = DictGer.wiederholen_V ;
|
|
repeat_V2 = P.dirV2 (DictGer.wiederholen_V) ;
|
|
repent_V = DictGer.bedauern_V ;
|
|
repent_V2 = P.dirV2 (DictGer.bedauern_V) ;
|
|
repertoire_N = DictGer.repertoire_N ;
|
|
repetition_N = DictGer.wiederholung_N ;
|
|
replace_V2 = P.dirV2 (DictGer.ersetzen_V) ;
|
|
replacement_N = DictGer.ersatz_N ;
|
|
reply_V = DictGer.antworten_V ;
|
|
reply_V2 = P.dirV2 (DictGer.antworten_V) ;
|
|
report_V = DictGer.berichten_V ;
|
|
report_V2 = P.dirV2 (DictGer.berichten_V) ;
|
|
reportage_N = DictGer.reportage_N ;
|
|
reporter_N = DictGer.reporter_N ;
|
|
repository_N = DictGer.ablage_N ;
|
|
reprehensible_A = DictGer.verwerflich_A ;
|
|
represent_V = DictGer.repraesentieren_V ;
|
|
represent_V2 = P.dirV2 (DictGer.repraesentieren_V) ;
|
|
representation_N = DictGer.darstellung_N ;
|
|
representative_A = DictGer.repraesentativ_A ;
|
|
repressive_A = DictGer.repressiv_A ;
|
|
reprint_N = DictGer.nachdruck_N ;
|
|
reproach_N = DictGer.vorwurf_N ;
|
|
reprove_V2 = P.dirV2 (DictGer.ruegen_V) ;
|
|
republic_N = DictGer.republik_N ;
|
|
repudiation_N = DictGer.ablehnung_N ;
|
|
reputation_N = DictGer.ansehen_N ;
|
|
repute_N = DictGer.ruf_N ;
|
|
request_N = DictGer.bitte_N ;
|
|
requiem_N = DictGer.totenmesse_N ;
|
|
require_V = DictGer.brauchen_4_V ;
|
|
require_V2 = P.dirV2 (DictGer.brauchen_4_V) ;
|
|
requirement_N = DictGer.anforderung_N ;
|
|
requite_V2 = P.dirV2 (DictGer.belohnen_V) ;
|
|
rescue_V2 = P.dirV2 (DictGer.retten_V) ;
|
|
rescuer_N = DictGer.retter_N ;
|
|
research_N = DictGer.forschung_N ;
|
|
researcher_N = DictGer.forscher_N ;
|
|
resemblance_N = DictGer.aehnlichkeit_N ;
|
|
resemble_V2 = P.dirV2 (DictGer.gleichen_V) ;
|
|
resentment_N = DictGer.abneigung_N ;
|
|
reserve_N = DictGer.reserve_N ;
|
|
reservoir_N = DictGer.reservoir_N ;
|
|
reside_V = DictGer.wohnen_1_V ;
|
|
residence_N = DictGer.firmensitz_N ;
|
|
resident_N = DictGer.bewohner_N ;
|
|
resign_V = DictGer.kuendigen_6_V ;
|
|
resign_V2 = P.dirV2 (DictGer.kuendigen_6_V) ;
|
|
resignation_N = DictGer.resignation_N ;
|
|
resilience_N = DictGer.resilienz_N ;
|
|
resin_N = DictGer.harz_N ;
|
|
resist_V = DictGer.widerstehen_V ;
|
|
resist_V2 = P.dirV2 (DictGer.widerstehen_V) ;
|
|
resistor_N = DictGer.widerstandskaempfer_N ;
|
|
resolute_A = DictGer.entschieden_A ;
|
|
resolution_N = DictGer.aufloesung_N ;
|
|
resort_N = DictGer.ausweg_N ;
|
|
resource_N = DictGer.mittel_N ;
|
|
resourceful_A = DictGer.findig_A ;
|
|
respectable_A = DictGer.angesehen_A ;
|
|
respective_A = DictGer.jeweilig_A ;
|
|
resplendent_A = DictGer.glaenzend_A ;
|
|
response_N = DictGer.antwort_N ;
|
|
responsibility_N = DictGer.verantwortung_N ;
|
|
responsible_A = DictGer.verantwortlich_A ;
|
|
rest_N = DictGer.lehne_N ;
|
|
restaurant_N = LexiconGer.restaurant_N ;
|
|
restitution_N = DictGer.entschaedigung_N ;
|
|
restless_A = DictGer.rastlos_A ;
|
|
restoration_N = DictGer.restauration_N ;
|
|
restraint_N = DictGer.beschraenkung_N ;
|
|
restrict_V = DictGer.beschraenken_V ;
|
|
restrict_V2 = P.dirV2 (DictGer.beschraenken_V) ;
|
|
restriction_N = DictGer.beschraenkung_N ;
|
|
resume_N = DictGer.lebenslauf_N ;
|
|
retailer_N = DictGer.einzelhaendler_N ;
|
|
retain_V2 = P.dirV2 (DictGer.behalten_4_V) ;
|
|
retaliation_N = DictGer.vergeltung_N ;
|
|
retch_V = DictGer.wuergen_2_V ;
|
|
reticence_N = DictGer.schweigsamkeit_N ;
|
|
reticent_A = DictGer.verschwiegen_A ;
|
|
retina_N = DictGer.netzhaut_N ;
|
|
retirement_N = DictGer.rente_N ;
|
|
retouch_V2 = P.dirV2 (DictGer.retuschieren_V) ;
|
|
retreat_N = DictGer.rueckzug_N ;
|
|
retrospect_N = DictGer.rueckblick_N ;
|
|
reunification_N = DictGer.wiedervereinigung_N ;
|
|
reunion_N = DictGer.treffen_N ;
|
|
revelation_N = DictGer.enthuellung_N ;
|
|
reveller_N = DictGer.nachtschwaermer_N ;
|
|
review_N = DictGer.rezension_N ;
|
|
revise_V = DictGer.revidieren_V ;
|
|
revise_V2 = P.dirV2 (DictGer.revidieren_V) ;
|
|
revision_N = DictGer.wiederholung_N ;
|
|
revival_N = DictGer.wiederbelebung_N ;
|
|
revocation_N = DictGer.widerruf_N ;
|
|
revoke_V = DictGer.revozieren_V ;
|
|
revoke_V2 = P.dirV2 (DictGer.revozieren_V) ;
|
|
revolution_N = DictGer.revolution_N ;
|
|
revolutionary_A = DictGer.revolutionaer_A ;
|
|
revolver_N = DictGer.revolver_N ;
|
|
revue_N = DictGer.revue_N ;
|
|
reward_N = DictGer.belohnung_N ;
|
|
rhea_N = DictGer.nandu_N ;
|
|
rhetoric_N = DictGer.rhetorik_N ;
|
|
rhetorical_A = DictGer.rhetorisch_A ;
|
|
rheumatic_A = DictGer.rheumatisch_A ;
|
|
rheumatism_N = DictGer.rheuma_N ;
|
|
rhinestone_N = DictGer.strass_N ;
|
|
rhinoceros_N = DictGer.nashorn_N ;
|
|
rhizome_N = DictGer.rhizom_N ;
|
|
rhododendron_N = DictGer.alpenrose_N ;
|
|
rhombus_N = DictGer.raute_N ;
|
|
rhubarb_N = DictGer.rhabarber_N ;
|
|
rhyme_N = DictGer.reim_N ;
|
|
rhymester_N = DictGer.dichterling_N ;
|
|
rhythmic_A = DictGer.rhythmisch_A ;
|
|
rib_N = DictGer.rippchen_N ;
|
|
ribald_A = DictGer.frivol_A ;
|
|
rich_A = DictGer.reich_A ;
|
|
rickshaw_N = DictGer.rikscha_N ;
|
|
riddle_N = DictGer.raetsel_N ;
|
|
ride_V = DictGer.fahren_7_V ;
|
|
ride_V2 = P.dirV2 (DictGer.fahren_7_V) ;
|
|
ridge_N = DictGer.grat_N ;
|
|
rifle_N = DictGer.gewehr_N ;
|
|
rig_N = DictGer.anlage_N ;
|
|
rigging_N = DictGer.takelage_N ;
|
|
right_A = DictGer.gerade_A ;
|
|
righteous_A = DictGer.gerecht_A ;
|
|
rightful_A = DictGer.rechtmaessig_A ;
|
|
rigid_A = DictGer.starr_A ;
|
|
rigmarole_N = DictGer.theater_N ;
|
|
rigorous_A = DictGer.gewaltig_A ;
|
|
rind_N = DictGer.rinde_N ;
|
|
ring_N = DictGer.ring_N ;
|
|
ringleader_N = DictGer.anfuehrer_N ;
|
|
rinse_V2 = P.dirV2 (DictGer.spuelen_1_V) ;
|
|
ripe_A = DictGer.reif_A ;
|
|
ripen_V = DictGer.reifen_V ;
|
|
ripen_V2 = P.dirV2 (DictGer.reifen_V) ;
|
|
risotto_N = DictGer.risotto_N ;
|
|
rival_N = DictGer.gegner_N ;
|
|
rivalry_N = DictGer.rivalitaet_N ;
|
|
river_N = LexiconGer.river_N ;
|
|
road_N = LexiconGer.road_N ;
|
|
roadstead_N = DictGer.reede_N ;
|
|
roam_V = DictGer.wandern_3_V ;
|
|
roam_V2 = P.dirV2 (DictGer.wandern_3_V) ;
|
|
roar_V = DictGer.bruellen_V ;
|
|
roar_V2 = P.dirV2 (DictGer.bruellen_V) ;
|
|
roast_V = DictGer.braten_V ;
|
|
roast_V2 = P.dirV2 (DictGer.braten_V) ;
|
|
robber_N = DictGer.raeuber_N ;
|
|
robbery_N = DictGer.raub_N ;
|
|
robe_N = DictGer.robe_N ;
|
|
robin_N = DictGer.rotkehlchen_N ;
|
|
robot_N = DictGer.roboter_N ;
|
|
robust_A = DictGer.robust_A ;
|
|
rock_N = LexiconGer.rock_N ;
|
|
rocket_N = DictGer.rakete_N ;
|
|
rocky_A = DictGer.steinig_A ;
|
|
rod_N = DictGer.stange_N ;
|
|
rodent_N = DictGer.nager_N ;
|
|
roe_N = DictGer.rogen_N ;
|
|
roebuck_N = DictGer.rehbock_N ;
|
|
rogue_N = DictGer.schurke_N ;
|
|
roil_V2 = P.dirV2 (DictGer.trueben_V) ;
|
|
roll_V = DictGer.laufen_9_V ;
|
|
roll_V2 = P.dirV2 (DictGer.laufen_9_V) ;
|
|
roller_N = DictGer.racke_N ;
|
|
romanian_A = DictGer.rumaenisch_A ;
|
|
romantic_A = DictGer.romantisch_A ;
|
|
romp_V = DictGer.raufen_V ;
|
|
roof_N = LexiconGer.roof_N ;
|
|
rook_N = DictGer.festung_N ;
|
|
rookie_N = DictGer.anfaenger_N ;
|
|
rooster_N = DictGer.hahn_N ;
|
|
root_N = LexiconGer.root_N ;
|
|
rope_N = LexiconGer.rope_N ;
|
|
rosary_N = DictGer.rosenkranz_N ;
|
|
rose_N = DictGer.rose_N ;
|
|
rosin_N = DictGer.kolophonium_N ;
|
|
rot_V = DictGer.verderben_V ;
|
|
rot_V2 = P.dirV2 (DictGer.verderben_V) ;
|
|
rotor_N = DictGer.rotor_N ;
|
|
rotten_A = LexiconGer.rotten_A ;
|
|
roue_N = DictGer.lustmolch_N ;
|
|
rough_A = DictGer.grob_A ;
|
|
roulette_N = DictGer.roulette_N ;
|
|
round_A = LexiconGer.round_A ;
|
|
roundish_A = DictGer.rundlich_A ;
|
|
row_N = DictGer.reihe_N ;
|
|
rowan_N = DictGer.eberesche_N ;
|
|
royal_A = DictGer.koeniglich_A ;
|
|
rub_V2 = LexiconGer.rub_V2 ;
|
|
rubber_N = LexiconGer.rubber_N ;
|
|
rubric_N = DictGer.rubrik_N ;
|
|
ruby_N = DictGer.rubin_N ;
|
|
rucksack_N = DictGer.rucksack_N ;
|
|
rude_A = DictGer.frech_A ;
|
|
rudimentary_A = DictGer.rudimentaer_A ;
|
|
ruff_N = DictGer.kampflaeufer_N ;
|
|
ruffle_N = DictGer.ruesche_N ;
|
|
rug_N = DictGer.bruecke_N ;
|
|
ruin_N = DictGer.ruine_N ;
|
|
rule_N = LexiconGer.rule_N ;
|
|
ruler_N = DictGer.herrscher_N ;
|
|
rum_N = DictGer.rum_N ;
|
|
rummage_V = DictGer.wuehlen_V ;
|
|
rummage_V2 = P.dirV2 (DictGer.wuehlen_V) ;
|
|
rummy_N = DictGer.romme_N ;
|
|
run_N = DictGer.lauf_N ;
|
|
run_V = LexiconGer.run_V ;
|
|
rune_N = DictGer.rune_N ;
|
|
rung_N = DictGer.sprosse_N ;
|
|
runner_N = DictGer.laeufer_N ;
|
|
rupee_N = DictGer.rupie_N ;
|
|
rupture_N = DictGer.bruch_N ;
|
|
rush_N = DictGer.binse_N ;
|
|
russian_N = DictGer.russe_N ;
|
|
rust_N = DictGer.rost_N ;
|
|
rustic_A = DictGer.rustikal_A ;
|
|
rusticate_V = DictGer.exmatrikulieren_V ;
|
|
rusticate_V2 = P.dirV2 (DictGer.exmatrikulieren_V) ;
|
|
rusty_A = DictGer.rostig_A ;
|
|
rut_N = DictGer.brunft_N ;
|
|
ruthless_A = DictGer.ruchlos_A ;
|
|
rye_N = DictGer.roggen_N ;
|
|
sable_N = DictGer.zobel_N ;
|
|
sabotage_N = DictGer.sabotage_N ;
|
|
sabre_N = DictGer.saebel_N ;
|
|
sack_N = DictGer.sack_N ;
|
|
sackbut_N = DictGer.posaune_N ;
|
|
sacrament_N = DictGer.sakrament_N ;
|
|
sacrifice_V = DictGer.opfern_V ;
|
|
sacrifice_V2 = P.dirV2 (DictGer.opfern_V) ;
|
|
sacrilege_N = DictGer.sakrileg_N ;
|
|
sacristan_N = DictGer.kuester_N ;
|
|
sacrosanct_A = DictGer.sakrosankt_A ;
|
|
sad_A = DictGer.traurig_A ;
|
|
sadden_V = DictGer.betrueben_V ;
|
|
sadden_V2 = P.dirV2 (DictGer.betrueben_V) ;
|
|
saddle_N = DictGer.ruecken_N ;
|
|
saddler_N = DictGer.sattler_N ;
|
|
safari_N = DictGer.safari_N ;
|
|
safe_A = DictGer.gefahrlos_A ;
|
|
saga_N = DictGer.saga_N ;
|
|
sagacious_A = DictGer.klug_A ;
|
|
sagacity_N = DictGer.weisheit_N ;
|
|
sail_N = DictGer.segel_N ;
|
|
sailor_N = DictGer.matrose_N ;
|
|
salacious_A = DictGer.anzueglich_A ;
|
|
salad_N = DictGer.salat_N ;
|
|
salamander_N = DictGer.salamander_N ;
|
|
salary_N = DictGer.gehalt_N ;
|
|
sale_N = DictGer.auktion_N ;
|
|
salesman_N = DictGer.verkaeufer_N ;
|
|
saleswoman_N = DictGer.verkaeuferin_N ;
|
|
salience_N = DictGer.salienz_N ;
|
|
saline_A = DictGer.salzhaltig_A ;
|
|
salivate_V = DictGer.geifern_V ;
|
|
sally_N = DictGer.ausfall_N ;
|
|
salmon_N = DictGer.lachs_N ;
|
|
salon_N = DictGer.salon__N ;
|
|
salt_N = LexiconGer.salt_N ;
|
|
salty_A = DictGer.salzhaltig_A ;
|
|
salvation_N = DictGer.erloesung_N ;
|
|
salvo_N = DictGer.salve_N ;
|
|
samovar_N = DictGer.samowar_N ;
|
|
sample_N = DictGer.muster_N ;
|
|
samurai_N = DictGer.samurai_N ;
|
|
sanatorium_N = DictGer.sanatorium_N ;
|
|
sanction_N = DictGer.sanktion_N ;
|
|
sand_N = LexiconGer.sand_N ;
|
|
sandal_N = DictGer.sandale_N ;
|
|
sandbag_N = DictGer.sandsack_N ;
|
|
sandpaper_N = DictGer.sandpapier_N ;
|
|
sandpit_N = DictGer.sandkasten_N ;
|
|
sandstone_N = DictGer.sandstein_N ;
|
|
sandstorm_N = DictGer.sandsturm_N ;
|
|
sandy_A = DictGer.sandig_A ;
|
|
sap_N = DictGer.saft_N ;
|
|
sapphire_N = DictGer.saphir_N ;
|
|
sarcasm_N = DictGer.sarkasmus_N ;
|
|
sarcastic_A = DictGer.sarkastisch_A ;
|
|
sarcophagus_N = DictGer.sarkophag_N ;
|
|
sardine_N = DictGer.sardine_N ;
|
|
sardonic_A = DictGer.bitter_A ;
|
|
satchel_N = DictGer.schulranzen_N ;
|
|
satellite_N = DictGer.satellit_N ;
|
|
satiate_V2 = P.dirV2 (DictGer.saettigen_V) ;
|
|
satire_N = DictGer.satire_N ;
|
|
satisfactory_A = DictGer.befriedigend_A ;
|
|
satisfy_V = DictGer.befriedigen_V ;
|
|
satisfy_V2 = P.dirV2 (DictGer.befriedigen_V) ;
|
|
satisfying_A = DictGer.befriedigend_A ;
|
|
satrap_N = DictGer.satrap_N ;
|
|
saturate_V2 = P.dirV2 (DictGer.saettigen_V) ;
|
|
saturday_N = DictGer.sabbat_N ;
|
|
sauce_N = DictGer.sauce_N ;
|
|
saucepan_N = DictGer.kochtopf_N ;
|
|
sausage_N = DictGer.wurst_N ;
|
|
savage_A = DictGer.grausam_A ;
|
|
savanna_N = DictGer.savanne_N ;
|
|
saw_N = DictGer.sprichwort_N ;
|
|
saxhorn_N = DictGer.buegelhorn_N ;
|
|
saxophone_N = DictGer.saxofon_N ;
|
|
saxophonist_N = DictGer.saxophonist_N ;
|
|
say_V = DictGer.sagen_8_V ;
|
|
say_V2 = P.dirV2 (DictGer.sagen_8_V) ;
|
|
scab_N = DictGer.schorf_N ;
|
|
scabbard_N = DictGer.scheide_N ;
|
|
scaffold_N = DictGer.geruest_N ;
|
|
scaffolding_N = DictGer.geruest_N ;
|
|
scale_N = DictGer.ausmass_N ;
|
|
scallop_N = DictGer.jakobsmuschel_N ;
|
|
scallywag_N = DictGer.taugenichts_N ;
|
|
scalpel_N = DictGer.skalpell_N ;
|
|
scamp_N = DictGer.gauner_N ;
|
|
scan_V = DictGer.skandieren_V ;
|
|
scan_V2 = P.dirV2 (DictGer.skandieren_V) ;
|
|
scandal_N = DictGer.skandal_N ;
|
|
scandalous_A = DictGer.skandaloes_A ;
|
|
scanner_N = DictGer.scanner_N ;
|
|
scant_A = DictGer.duerftig_A ;
|
|
scapegoat_N = DictGer.pruegelknabe_N ;
|
|
scar_N = DictGer.narbe_N ;
|
|
scarce_A = DictGer.spaerlich_A ;
|
|
scarcity_N = DictGer.mangel_N ;
|
|
scarecrow_N = DictGer.vogelscheuche_N ;
|
|
scatter_V = DictGer.streuen_V ;
|
|
scatter_V2 = P.dirV2 (DictGer.streuen_V) ;
|
|
scavenger_N = DictGer.aasfresser_N ;
|
|
scenario_N = DictGer.drehbuch_N ;
|
|
scene_N = DictGer.szene_N ;
|
|
scent_N = DictGer.duft_N ;
|
|
sceptical_A = DictGer.skeptisch_A ;
|
|
schedule_N = DictGer.programm_N ;
|
|
schematic_A = DictGer.schematisch_A ;
|
|
schist_N = DictGer.schiefer_N ;
|
|
schizophrenia_N = DictGer.schizophrenie_N ;
|
|
schizophrenic_A = DictGer.schizophren_A ;
|
|
schnapps_N = DictGer.schnaps_N ;
|
|
schnitzel_N = DictGer.schnitzel_N ;
|
|
scholarship_N = DictGer.stipendium_N ;
|
|
school_N = LexiconGer.school_N ;
|
|
schoolchild_N = DictGer.schueler_N ;
|
|
schoolmate_N = DictGer.mitschueler_N ;
|
|
schooner_N = DictGer.schoner_N ;
|
|
science_N = LexiconGer.science_N ;
|
|
scientific_A = DictGer.wissenschaftlich_A ;
|
|
scientist_N = DictGer.wissenschaftlerin_N ;
|
|
scion_N = DictGer.nachkomme_N ;
|
|
scoop_N = DictGer.schaufel_N ;
|
|
scooter_N = DictGer.motorroller_N ;
|
|
scope_N = DictGer.umfang_N ;
|
|
scorn_V2 = P.dirV2 (DictGer.verschmaehen_V) ;
|
|
scornful_A = DictGer.veraechtlich_A ;
|
|
scorpion_N = DictGer.skorpion_N ;
|
|
scoundrel_N = DictGer.gauner_N ;
|
|
scourge_N = DictGer.geissel_N ;
|
|
scout_N = DictGer.pfadfinder_N ;
|
|
scrape_V = DictGer.kratzen_6_V ;
|
|
scrape_V2 = P.dirV2 (DictGer.kratzen_6_V) ;
|
|
scratch_V = DictGer.kratzen_6_V ;
|
|
scratch_V2 = LexiconGer.scratch_V2 ;
|
|
scrawny_A = DictGer.duerr_A ;
|
|
scream_N = DictGer.aufschrei_N ;
|
|
screen_N = DictGer.bildschirm_N ;
|
|
screw_N = DictGer.schraube_N ;
|
|
screwdriver_N = DictGer.schraubendreher_N ;
|
|
scribe_N = DictGer.schreiber_N ;
|
|
script_N = DictGer.drehbuch_N ;
|
|
scripture_N = DictGer.schrift_N ;
|
|
scrivener_N = DictGer.schreiber_N ;
|
|
scroll_N = DictGer.schnecke_N ;
|
|
scrooge_N = DictGer.geizhals_N ;
|
|
scrotum_N = DictGer.hodensack_N ;
|
|
scrounge_V = DictGer.klauben_V ;
|
|
scrounge_V2 = P.dirV2 (DictGer.klauben_V) ;
|
|
scrumptious_A = DictGer.lecker_A ;
|
|
scruple_N = DictGer.skrupel_N ;
|
|
scrupulous_A = DictGer.gewissenhaft_A ;
|
|
sculpt_V = DictGer.formen_8_V ;
|
|
sculpt_V2 = P.dirV2 (DictGer.formen_8_V) ;
|
|
sculpture_N = DictGer.skulptur_N ;
|
|
scuttle_N = DictGer.luke_N ;
|
|
scythe_N = DictGer.sense_N ;
|
|
sea_N = LexiconGer.sea_N ;
|
|
seabird_N = DictGer.seevogel_N ;
|
|
seafarer_N = DictGer.seefahrer_N ;
|
|
seagull_N = DictGer.moewe_N ;
|
|
seal_N = DictGer.dichtung_N ;
|
|
seam_N = DictGer.floez_N ;
|
|
seamstress_N = DictGer.naeherin_N ;
|
|
seaplane_N = DictGer.wasserflugzeug_N ;
|
|
seaport_N = DictGer.hafenstadt_N ;
|
|
sear_V2 = P.dirV2 (DictGer.verbrennen_V) ;
|
|
search_V = DictGer.suchen_V ;
|
|
search_V2 = P.dirV2 (DictGer.suchen_V) ;
|
|
seascape_N = DictGer.seestueck_N ;
|
|
season_N = DictGer.jahreszeit_N ;
|
|
seasoning_N = DictGer.gewuerz_N ;
|
|
seaweed_N = DictGer.tang_N ;
|
|
secession_N = DictGer.sezession_N ;
|
|
secluded_A = DictGer.abgesondert_A ;
|
|
secret_N = DictGer.geheimnis_N ;
|
|
secretary_N = DictGer.minister_N ;
|
|
secretion_N = DictGer.secretion_N ;
|
|
secretive_A = DictGer.verschlossen_A ;
|
|
sect_N = DictGer.sekte_N ;
|
|
section_N = DictGer.abschnitt_N ;
|
|
secular_A = DictGer.saekular_A ;
|
|
secularism_N = DictGer.saekularismus_N ;
|
|
secure_A = DictGer.zuverlaessig_A ;
|
|
security_N = DictGer.sicherheit_N ;
|
|
sedan_N = DictGer.saenfte_N ;
|
|
sedative_N = DictGer.beruhigungsmittel_N ;
|
|
sedentary_A = DictGer.ortsgebunden_A ;
|
|
seduce_V2 = P.dirV2 (DictGer.verfuehren_V) ;
|
|
see_V = DictGer.schauen_0_V ;
|
|
see_V2 = LexiconGer.see_V2 ;
|
|
seed_N = LexiconGer.seed_N ;
|
|
seedless_A = DictGer.kernlos_A ;
|
|
seek_V2 = LexiconGer.seek_V2 ;
|
|
seem_V = DictGer.duenken_V ;
|
|
seem_V2 = P.dirV2 (DictGer.duenken_V) ;
|
|
seer_N = DictGer.seher_N ;
|
|
seethe_V = DictGer.sieden_V ;
|
|
seethe_V2 = P.dirV2 (DictGer.sieden_V) ;
|
|
segment_N = DictGer.segment_N ;
|
|
segregation_N = DictGer.rassentrennung_N ;
|
|
seismic_A = DictGer.seismisch_A ;
|
|
seismograph_N = DictGer.seismograf_N ;
|
|
seize_V = DictGer.ergreifen_V ;
|
|
seize_V2 = P.dirV2 (DictGer.ergreifen_V) ;
|
|
seizure_N = DictGer.anfall_N ;
|
|
selection_N = DictGer.aufruf_N ;
|
|
selective_A = DictGer.waehlerisch_A ;
|
|
selenium_N = DictGer.selenium_N ;
|
|
selfishness_N = DictGer.egoismus_N ;
|
|
sell_V = DictGer.verkaufen_V ;
|
|
sell_V2 = P.dirV2 (DictGer.verkaufen_V) ;
|
|
seller_N = DictGer.verkaeufer_N ;
|
|
semantic_A = DictGer.semantisch_A ;
|
|
semen_N = DictGer.samen_N ;
|
|
semester_N = DictGer.halbjahr_N ;
|
|
semicircle_N = DictGer.halbkreis_N ;
|
|
semicolon_N = DictGer.strichpunkt_N ;
|
|
semiconductor_N = DictGer.halbleiter_N ;
|
|
semifinal_N = DictGer.halbfinale_N ;
|
|
seminal_A = DictGer.einflussreich_A ;
|
|
seminar_N = DictGer.kolloquium_N ;
|
|
semivowel_N = DictGer.halbvokal_N ;
|
|
semolina_N = DictGer.griess_N ;
|
|
senate_N = DictGer.senat_N ;
|
|
senator_N = DictGer.senator_N ;
|
|
send_V = DictGer.schicken_0_V ;
|
|
send_V2 = P.dirV2 (DictGer.schicken_0_V) ;
|
|
sender_N = DictGer.absender_N ;
|
|
senescence_N = DictGer.alterungsprozess_N ;
|
|
senile_A = DictGer.senil_A ;
|
|
sensation_N = DictGer.gefuehl_N ;
|
|
sense_N = DictGer.bedeutung_N ;
|
|
sensible_A = DictGer.spuerbar_A ;
|
|
sensitive_A = DictGer.empfindlich_A ;
|
|
sensual_A = DictGer.sinnlich_A ;
|
|
sentence_N = DictGer.satz_N ;
|
|
sentimental_A = DictGer.sentimental_A ;
|
|
sentimentality_N = DictGer.empfindsamkeit_N ;
|
|
sentinel_N = DictGer.wache_N ;
|
|
sentry_N = DictGer.wache_N ;
|
|
separate_A = DictGer.einzeln_A ;
|
|
separation_N = DictGer.trennung_N ;
|
|
septic_A = DictGer.septisch_A ;
|
|
sepulchral_A = DictGer.duester_A ;
|
|
sequel_N = DictGer.folge_N ;
|
|
sequence_N = DictGer.folge_N ;
|
|
sere_A = DictGer.trocken_A ;
|
|
serenade_N = DictGer.serenade_N ;
|
|
serenity_N = DictGer.durchlaucht_N ;
|
|
sergeant_N = DictGer.feldwebel_N ;
|
|
series_N = DictGer.reihe_N ;
|
|
serious_A = DictGer.ernst_A ;
|
|
sermon_N = DictGer.predigt_N ;
|
|
serpent_N = DictGer.schlange_N ;
|
|
serpentine_A = DictGer.schlangenfoermig_A ;
|
|
serum_N = DictGer.serum_N ;
|
|
server_N = DictGer.server_N ;
|
|
service_N = DictGer.angabe_N ;
|
|
sesame_N = DictGer.sesam_N ;
|
|
session_N = DictGer.sitzung_N ;
|
|
set_V = DictGer.bereitstellen_0_V ;
|
|
set_V2 = P.dirV2 (DictGer.bereitstellen_0_V) ;
|
|
settee_N = DictGer.sofa_N ;
|
|
settlement_N = DictGer.ansiedlung_N ;
|
|
settler_N = DictGer.siedler_N ;
|
|
severity_N = DictGer.haerte_N ;
|
|
sew_V = LexiconGer.sew_V ;
|
|
sew_V2 = P.dirV2 (DictGer.naehen_V) ;
|
|
sewer_N = DictGer.kanalisation_N ;
|
|
sewerage_N = DictGer.kanalisation_N ;
|
|
sex_N = DictGer.geschlecht_N ;
|
|
sexless_A = DictGer.geschlechtslos_A ;
|
|
sextant_N = DictGer.sextant_N ;
|
|
sexton_N = DictGer.kuester_N ;
|
|
sexuality_N = DictGer.geschlecht_N ;
|
|
sexy_A = DictGer.sexy_A ;
|
|
shabbiness_N = DictGer.schaebigkeit_N ;
|
|
shabby_A = DictGer.schaebig_A ;
|
|
shack_N = DictGer.bude_N ;
|
|
shackle_N = DictGer.schaekel_N ;
|
|
shade_N = DictGer.farbton_N ;
|
|
shadow_N = DictGer.schatten_N ;
|
|
shaft_N = DictGer.schacht_N ;
|
|
shaggy_A = DictGer.struppig_A ;
|
|
shah_N = DictGer.schah_N ;
|
|
shake_V = DictGer.erschuettern_V ;
|
|
shake_V2 = P.dirV2 (DictGer.erschuettern_V) ;
|
|
shale_N = DictGer.schiefer_N ;
|
|
shallot_N = DictGer.schalotte_N ;
|
|
shallow_A = DictGer.flach_A ;
|
|
shameless_A = DictGer.schamlos_A ;
|
|
shampoo_N = DictGer.haarwaschmittel_N ;
|
|
shamrock_N = DictGer.kleeblatt_N ;
|
|
shanghai_V2 = P.dirV2 (DictGer.schanghaien_V) ;
|
|
shape_N = DictGer.form_N ;
|
|
shard_N = DictGer.scherbe_N ;
|
|
share_N = DictGer.aktie_N ;
|
|
shareholder_N = DictGer.aktionaer_N ;
|
|
shark_N = DictGer.hai_N ;
|
|
sharp_A = LexiconGer.sharp_A ;
|
|
sharpener_N = DictGer.spitzer_N ;
|
|
sharpshooter_N = DictGer.scharfschuetze_N ;
|
|
shave_V = DictGer.rasieren_V ;
|
|
shave_V2 = P.dirV2 (DictGer.rasieren_V) ;
|
|
sheaf_N = DictGer.garbe_N ;
|
|
shear_V2 = P.dirV2 (DictGer.scheren_V) ;
|
|
sheath_N = DictGer.huelle_N ;
|
|
shed_V2 = P.dirV2 (DictGer.vergiessen_V) ;
|
|
sheep_N = LexiconGer.sheep_N ;
|
|
sheepdog_N = DictGer.schaeferhund_N ;
|
|
sheepfold_N = DictGer.schafstall_N ;
|
|
sheer_A = DictGer.bloss_A ;
|
|
sheet_N = DictGer.blatt_N ;
|
|
shekel_N = DictGer.schekel_N ;
|
|
shell_N = DictGer.eierschale_N ;
|
|
shellac_N = DictGer.schellack_N ;
|
|
shelter_N = DictGer.zufluchtsort_N ;
|
|
shepherd_N = DictGer.hirte_N ;
|
|
shepherdess_N = DictGer.schafhirtin_N ;
|
|
sherbet_N = DictGer.brausepulver_N ;
|
|
shield_N = DictGer.schild_N ;
|
|
shimmer_V = DictGer.schimmern_V ;
|
|
shin_N = DictGer.schienbein_N ;
|
|
shinbone_N = DictGer.schienbein_N ;
|
|
shine_V = DictGer.glaenzen_V ;
|
|
shine_V2 = P.dirV2 (DictGer.glaenzen_V) ;
|
|
shingle_N = DictGer.schindel_N ;
|
|
shiny_A = DictGer.glaenzend_A ;
|
|
ship_N = LexiconGer.ship_N ;
|
|
shipping_N = DictGer.schifffahrt_N ;
|
|
shipwreck_N = DictGer.schiffbruch_N ;
|
|
shipyard_N = DictGer.werft_N ;
|
|
shirt_N = LexiconGer.shirt_N ;
|
|
shit_N = DictGer.durchfall_N ;
|
|
shoddy_A = DictGer.minderwertig_A ;
|
|
shoe_N = LexiconGer.shoe_N ;
|
|
shoehorn_N = DictGer.schuhanzieher_N ;
|
|
shoelace_N = DictGer.schnuersenkel_N ;
|
|
shoemaker_N = DictGer.schuhmacher_N ;
|
|
shoot_V = DictGer.schiessen_V ;
|
|
shoot_V2 = P.dirV2 (DictGer.schiessen_V) ;
|
|
shooter_N = DictGer.ballerspiel_N ;
|
|
shop_N = LexiconGer.shop_N ;
|
|
shopkeeper_N = DictGer.haendler_N ;
|
|
shoplift_V = DictGer.klauen_V ;
|
|
shoplift_V2 = P.dirV2 (DictGer.klauen_V) ;
|
|
shoplifting_N = DictGer.ladendiebstahl_N ;
|
|
shore_N = DictGer.ufer_N ;
|
|
short_A = LexiconGer.short_A ;
|
|
shortcoming_N = DictGer.manko_N ;
|
|
shorthand_N = DictGer.kurzschrift_N ;
|
|
shotgun_N = DictGer.beifahrersitz_N ;
|
|
shoulder_N = DictGer.schulter_N ;
|
|
shout_N = DictGer.schrei_N ;
|
|
shove_V = DictGer.schubsen_V ;
|
|
shove_V2 = P.dirV2 (DictGer.schubsen_V) ;
|
|
shovel_N = DictGer.schaufel_N ;
|
|
show_V = DictGer.zeigen_7_V ;
|
|
show_V2 = P.dirV2 (DictGer.zeigen_7_V) ;
|
|
shower_N = DictGer.brause_N ;
|
|
shrewd_A = DictGer.klug_A ;
|
|
shrike_N = DictGer.wuerger_N ;
|
|
shrill_A = DictGer.scharf_A ;
|
|
shrimp_N = DictGer.garnele_N ;
|
|
shrine_N = DictGer.schrein_N ;
|
|
shrink_V = DictGer.schrumpfen_V ;
|
|
shrink_V2 = P.dirV2 (DictGer.schrumpfen_V) ;
|
|
shrub_N = DictGer.busch_N ;
|
|
shrug_N = DictGer.schulterzucken_N ;
|
|
shunt_V = DictGer.rangieren_V ;
|
|
shunt_V2 = P.dirV2 (DictGer.rangieren_V) ;
|
|
shut_V = DictGer.schliessen_0_V ;
|
|
shut_V2 = P.dirV2 (DictGer.schliessen_0_V) ;
|
|
shuttlecock_N = DictGer.federball_N ;
|
|
shy_A = DictGer.scheu_A ;
|
|
sibling_N = DictGer.bruder_N ;
|
|
sickbay_N = DictGer.krankenzimmer_N ;
|
|
sickening_A = DictGer.ekelhaft_A ;
|
|
sickle_N = DictGer.sichel_N ;
|
|
sickly_A = DictGer.fahl_A ;
|
|
sickness_N = DictGer.krankheit_N ;
|
|
side_N = DictGer.seite_N ;
|
|
sidecar_N = DictGer.beiwagen_N ;
|
|
sidereal_A = DictGer.siderisch_A ;
|
|
sidewalk_N = DictGer.buergersteig_N ;
|
|
siege_N = DictGer.belagerung_N ;
|
|
sieve_N = DictGer.sieb_N ;
|
|
sift_V = DictGer.sieben_V ;
|
|
sift_V2 = P.dirV2 (DictGer.sieben_V) ;
|
|
sight_N = DictGer.sehenswuerdigkeit_N ;
|
|
sightseeing_N = DictGer.besichtigung_N ;
|
|
sign_N = DictGer.anzeichen_N ;
|
|
signal_N = DictGer.signal_N ;
|
|
signature_N = DictGer.unterschrift_N ;
|
|
significance_N = DictGer.bedeutung_N ;
|
|
significant_A = DictGer.bedeutend_A ;
|
|
silence_N = DictGer.stille_N ;
|
|
silent_A = DictGer.schweigsam_A ;
|
|
silhouette_N = DictGer.silhouette_N ;
|
|
silicate_N = DictGer.silikat_N ;
|
|
silk_N = DictGer.seide_N ;
|
|
silken_A = DictGer.seiden_A ;
|
|
silky_A = DictGer.seidig_A ;
|
|
silly_A = DictGer.doof_A ;
|
|
silver_N = LexiconGer.silver_N ;
|
|
similarity_N = DictGer.aehnlichkeit_N ;
|
|
simile_N = DictGer.vergleich_N ;
|
|
simony_N = DictGer.simonie_N ;
|
|
simple_A = DictGer.einfach_A ;
|
|
simpleton_N = DictGer.einfaltspinsel_N ;
|
|
simplify_V = DictGer.vereinfachen_V ;
|
|
simplify_V2 = P.dirV2 (DictGer.vereinfachen_V) ;
|
|
simulator_N = DictGer.simulator_N ;
|
|
simultaneous_A = DictGer.gleichzeitig_A ;
|
|
sin_N = DictGer.suende_N ;
|
|
sincere_A = DictGer.aufrichtig_A ;
|
|
sincerity_N = DictGer.aufrichtigkeit_N ;
|
|
sing_V = LexiconGer.sing_V ;
|
|
sing_V2 = P.dirV2 (DictGer.singen_V) ;
|
|
singer_N = DictGer.saenger_N ;
|
|
singing_N = DictGer.gesang_N ;
|
|
single_A = DictGer.allein_A ;
|
|
singleton_N = DictGer.einermenge_N ;
|
|
singular_A = DictGer.einzigartig_A ;
|
|
singularity_N = DictGer.eigenheit_N ;
|
|
sink_V = DictGer.sinken_V ;
|
|
sink_V2 = P.dirV2 (DictGer.sinken_V) ;
|
|
sinner_N = DictGer.suender_N ;
|
|
sinusitis_N = DictGer.sinusitis_N ;
|
|
sissy_N = DictGer.memme_N ;
|
|
sister_N = LexiconGer.sister_N ;
|
|
sit_V = LexiconGer.sit_V ;
|
|
sit_V2 = P.dirV2 (DictGer.liegen_3_V) ;
|
|
sitar_N = DictGer.sitar_N ;
|
|
site_N = DictGer.standort_N ;
|
|
situation_N = DictGer.lage_N ;
|
|
size_N = DictGer.groesse_N ;
|
|
sizzle_V = DictGer.zischen_V ;
|
|
skate_N = DictGer.eislaufen_N ;
|
|
skateboard_N = DictGer.skateboard_N ;
|
|
skein_N = DictGer.strang_N ;
|
|
skeleton_N = DictGer.gerippe_N ;
|
|
skeptical_A = DictGer.skeptisch_A ;
|
|
sketch_V = DictGer.skizzieren_V ;
|
|
sketch_V2 = P.dirV2 (DictGer.skizzieren_V) ;
|
|
skew_A = DictGer.schief_A ;
|
|
skewer_N = DictGer.spiess_N ;
|
|
skid_N = DictGer.kufe_N ;
|
|
skier_N = DictGer.skifahrer__N ;
|
|
skilful_A = DictGer.geschickt_A ;
|
|
skillet_N = DictGer.bratpfanne_N ;
|
|
skim_V = DictGer.ueberfliegen_V ;
|
|
skim_V2 = P.dirV2 (DictGer.ueberfliegen_V) ;
|
|
skin_N = LexiconGer.skin_N ;
|
|
skinflint_N = DictGer.geizhals_N ;
|
|
skinhead_N = DictGer.skinhead_N ;
|
|
skip_V = DictGer.huepfen_V ;
|
|
skip_V2 = P.dirV2 (DictGer.huepfen_V) ;
|
|
skipper_N = DictGer.schiffer_N ;
|
|
skirmish_N = DictGer.scharmuetzel_N ;
|
|
skirt_N = DictGer.rock_N ;
|
|
skull_N = DictGer.totenkopf_N ;
|
|
skullcap_N = DictGer.kippa_N ;
|
|
skunk_N = DictGer.stinktier_N ;
|
|
sky_N = LexiconGer.sky_N ;
|
|
skylark_N = DictGer.lerche_N ;
|
|
skylight_N = DictGer.dachfenster_N ;
|
|
skyscraper_N = DictGer.hochhaus_N ;
|
|
slab_N = DictGer.fliese_N ;
|
|
slag_N = DictGer.schlacke_N ;
|
|
slander_N = DictGer.verleumdung_N ;
|
|
slang_N = DictGer.jargon_N ;
|
|
slap_N = DictGer.klaps_N ;
|
|
slash_N = DictGer.bruchstrich_N ;
|
|
slate_N = DictGer.schiefer_N ;
|
|
slaughter_N = DictGer.gemetzel_N ;
|
|
slaughterer_N = DictGer.fleischer_N ;
|
|
slaughterhouse_N = DictGer.schlachthof_N ;
|
|
slave_N = DictGer.sklave_N ;
|
|
slaver_V = DictGer.sabbern_V ;
|
|
slay_V2 = P.dirV2 (DictGer.ermorden_V) ;
|
|
sleazy_A = DictGer.frivol_A ;
|
|
sled_N = DictGer.schlitten_N ;
|
|
sleek_A = DictGer.geschmeidig_A ;
|
|
sleep_V = LexiconGer.sleep_V ;
|
|
sleeper_N = DictGer.schlaefer_N ;
|
|
sleepy_A = DictGer.schlaefrig_A ;
|
|
sleet_N = DictGer.eisregen_N ;
|
|
sleeve_N = DictGer.aermel_N ;
|
|
sleeveless_A = DictGer.aermellos_A ;
|
|
slender_A = DictGer.schlank_A ;
|
|
slice_N = DictGer.anteil_N ;
|
|
slide_V = DictGer.gleiten_V ;
|
|
slide_V2 = P.dirV2 (DictGer.gleiten_V) ;
|
|
slight_A = DictGer.geringfuegig_A ;
|
|
slim_A = DictGer.schlank_A ;
|
|
slime_N = DictGer.schleim_N ;
|
|
slip_N = DictGer.ausrutscher_N ;
|
|
slipper_N = DictGer.hausschuh_N ;
|
|
slipshod_A = DictGer.schlampig_A ;
|
|
slit_N = DictGer.schlitz_N ;
|
|
sliver_N = DictGer.splitter_N ;
|
|
slogan_N = DictGer.losung_N ;
|
|
slope_N = DictGer.hang_N ;
|
|
sloppy_A = DictGer.schlampig_A ;
|
|
slot_N = DictGer.schlitz_N ;
|
|
sloth_N = DictGer.faultier_N ;
|
|
slow_A = DictGer.dumm_A ;
|
|
sludge_N = DictGer.schlamm_N ;
|
|
slug_N = DictGer.nacktschnecke_N ;
|
|
sluice_N = DictGer.schleuse_N ;
|
|
slum_N = DictGer.slum_N ;
|
|
slut_N = DictGer.flittchen_N ;
|
|
sly_A = DictGer.gerissen_A ;
|
|
small_A = LexiconGer.small_A ;
|
|
smart_V = DictGer.schmerzen_V ;
|
|
smattering_N = DictGer.halbwissen_N ;
|
|
smell_N = DictGer.geruch_N ;
|
|
smell_V = LexiconGer.smell_V ;
|
|
smile_N = DictGer.laecheln_N ;
|
|
smoke_N = LexiconGer.smoke_N ;
|
|
smoker_N = DictGer.raucher_N ;
|
|
smokestack_N = DictGer.schornstein_N ;
|
|
smooth_A = LexiconGer.smooth_A ;
|
|
smoothness_N = DictGer.glaette_N ;
|
|
smudge_N = DictGer.fleck_N ;
|
|
smug_A = DictGer.blasiert_A ;
|
|
smuggle_V2 = P.dirV2 (DictGer.schmuggeln_V) ;
|
|
smuggler_N = DictGer.schmuggler_N ;
|
|
snack_N = DictGer.happen_N ;
|
|
snail_N = DictGer.schnecke_N ;
|
|
snake_N = LexiconGer.snake_N ;
|
|
snapshot_N = DictGer.schnappschuss__N ;
|
|
snatch_V = DictGer.klauen_V ;
|
|
snatch_V2 = P.dirV2 (DictGer.klauen_V) ;
|
|
sneer_V = DictGer.grinsen_V ;
|
|
sneeze_V = DictGer.niesen_V ;
|
|
snipe_N = DictGer.schnepfe_N ;
|
|
sniper_N = DictGer.heckenschuetze_N ;
|
|
snitch_V = DictGer.klauen_V ;
|
|
snitch_V2 = P.dirV2 (DictGer.klauen_V) ;
|
|
snobbery_N = DictGer.snobismus_N ;
|
|
snore_V = DictGer.schnarchen_V ;
|
|
snorkel_N = DictGer.schnorchel_N ;
|
|
snotty_A = DictGer.patzig_A ;
|
|
snout_N = DictGer.ruessel_N ;
|
|
snow_N = LexiconGer.snow_N ;
|
|
snowball_N = DictGer.schneeball_N ;
|
|
snowdrop_N = DictGer.schneegloeckchen_N ;
|
|
snowfall_N = DictGer.schneefall_N ;
|
|
snowflake_N = DictGer.maerzenbecher_N ;
|
|
snowman_N = DictGer.schneemann_N ;
|
|
snowstorm_N = DictGer.schneesturm_N ;
|
|
soap_N = DictGer.seife_N ;
|
|
sober_A = DictGer.besonnen_A ;
|
|
sobriquet_N = DictGer.beiname_N ;
|
|
soccer_N = DictGer.fussball_N ;
|
|
sociable_A = DictGer.gesellig_A ;
|
|
socialist_A = DictGer.sozialistisch_A ;
|
|
society_N = DictGer.gesellschaft_N ;
|
|
sociologist_N = DictGer.soziologe_N ;
|
|
sock_N = LexiconGer.sock_N ;
|
|
socket_N = DictGer.fassung_N ;
|
|
sodium_N = DictGer.sodium_N ;
|
|
sofa_N = DictGer.sofa_N ;
|
|
soft_A = DictGer.leise_A ;
|
|
soil_N = DictGer.boden_N ;
|
|
soiree_N = DictGer.soiree_N ;
|
|
sojourn_N = DictGer.aufenthalt_N ;
|
|
solarium_N = DictGer.solarium_N ;
|
|
solder_N = DictGer.lot_N ;
|
|
soldier_N = DictGer.soldat_N ;
|
|
sole_N = DictGer.fusssohle_N ;
|
|
solemn_A = DictGer.ernst_A ;
|
|
solid_A = DictGer.buendig_A ;
|
|
solidarity_N = DictGer.solidaritaet_N ;
|
|
solidify_V = DictGer.erstarren_V ;
|
|
solidify_V2 = P.dirV2 (DictGer.erstarren_V) ;
|
|
soliloquy_N = DictGer.monolog_N ;
|
|
solitude_N = DictGer.einsamkeit_N ;
|
|
soloist_N = DictGer.solist_N ;
|
|
solstice_N = DictGer.sonnenwende_N ;
|
|
soluble_A = DictGer.loeslich_A ;
|
|
solution_N = DictGer.loesung_N ;
|
|
solvable_A = DictGer.loeslich_A ;
|
|
solve_V2 = P.dirV2 (DictGer.loesen_5_V) ;
|
|
solvency_N = DictGer.solvenz_N ;
|
|
solvent_N = DictGer.loesemittel_N ;
|
|
somersault_N = DictGer.purzelbaum_N ;
|
|
somnolent_A = DictGer.schlaefrig_A ;
|
|
son_N = DictGer.sohn_N ;
|
|
sonata_N = DictGer.sonate_N ;
|
|
song_N = LexiconGer.song_N ;
|
|
songbird_N = DictGer.singvogel_N ;
|
|
sonnet_N = DictGer.sonett_N ;
|
|
soot_N = DictGer.russ_N ;
|
|
soothsayer_N = DictGer.seher_N ;
|
|
soprano_N = DictGer.sopran_N ;
|
|
sorbet_N = DictGer.sorbet_N ;
|
|
sorcerer_N = DictGer.zauberer_N ;
|
|
sorceress_N = DictGer.zauberin_N ;
|
|
sordid_A = DictGer.dreckig_A ;
|
|
sore_A = DictGer.entzuendet_A ;
|
|
soreness_N = DictGer.schmerz_N ;
|
|
sorrel_N = DictGer.ampfer_N ;
|
|
sorrow_N = DictGer.leiden_N ;
|
|
sorrowful_A = DictGer.betruebt_A ;
|
|
sorry_A = DictGer.armselig_A ;
|
|
sort_N = DictGer.art_N ;
|
|
souffle_N = DictGer.auflauf_N ;
|
|
soul_N = DictGer.seele_N ;
|
|
sound_A = DictGer.gesund_A ;
|
|
soundtrack_N = DictGer.soundtrack_N ;
|
|
soup_N = DictGer.suppe_N ;
|
|
sour_A = DictGer.sauer_A ;
|
|
source_N = DictGer.quellcode_N ;
|
|
soutane_N = DictGer.soutane_N ;
|
|
southern_A = DictGer.suedlich_A ;
|
|
southpaw_N = DictGer.linkshaender_N ;
|
|
souvenir_N = DictGer.souvenir_N ;
|
|
sovereignty_N = DictGer.souveraenitaet_N ;
|
|
soviet_N = DictGer.sowjet_N ;
|
|
soy_N = DictGer.soja_N ;
|
|
spa_N = DictGer.bad_N ;
|
|
space_N = DictGer.freiraum_N ;
|
|
spacecraft_N = DictGer.raumschiff_N ;
|
|
spaceship_N = DictGer.raumschiff_N ;
|
|
spade_N = DictGer.pik_N ;
|
|
spanish_A = DictGer.spanisch_A ;
|
|
spanner_N = DictGer.schluessel_N ;
|
|
spark_N = DictGer.funke_N ;
|
|
sparrow_N = DictGer.sperling_N ;
|
|
sparse_A = DictGer.spaerlich_A ;
|
|
spasm_N = DictGer.krampf_N ;
|
|
spatial_A = DictGer.raeumlich_A ;
|
|
spatula_N = DictGer.pfannenwender_N ;
|
|
spawn_V = DictGer.erzeugen_V ;
|
|
spawn_V2 = P.dirV2 (DictGer.erzeugen_V) ;
|
|
speak_V = DictGer.reden_9_V ;
|
|
speak_V2 = LexiconGer.speak_V2 ;
|
|
speaker_N = DictGer.lautsprecher_N ;
|
|
spear_N = DictGer.speer_N ;
|
|
speciality_N = DictGer.spezialitaet_N ;
|
|
specialty_N = DictGer.spezialitaet_N ;
|
|
species_N = DictGer.gattung_N ;
|
|
specification_N = DictGer.spezifikation__N ;
|
|
specimen_N = DictGer.exemplar_N ;
|
|
specious_A = DictGer.fadenscheinig_A ;
|
|
speck_N = DictGer.fleck_N ;
|
|
spectacle_N = DictGer.schauspiel_N ;
|
|
spectacular_A = DictGer.spektakulaer_A ;
|
|
spectator_N = DictGer.zuschauer_N ;
|
|
spectrum_N = DictGer.spektrum_N ;
|
|
speculate_V = DictGer.vermuten_V ;
|
|
speculation_N = DictGer.spekulation_N ;
|
|
speculative_A = DictGer.spekulativ_A ;
|
|
speculator_N = DictGer.spekulant_N ;
|
|
speech_N = DictGer.ansprache_N ;
|
|
speechless_A = DictGer.sprachlos_A ;
|
|
speed_N = DictGer.geschwindigkeit_N ;
|
|
speedy_A = DictGer.schnell_A ;
|
|
spell_N = DictGer.zauber_N ;
|
|
spend_V = DictGer.verbringen_V ;
|
|
spend_V2 = P.dirV2 (DictGer.verbringen_V) ;
|
|
sperm_N = DictGer.samenzelle_N ;
|
|
spermatozoon_N = DictGer.spermium_N ;
|
|
spew_V = DictGer.erbrechen_V ;
|
|
spew_V2 = P.dirV2 (DictGer.erbrechen_V) ;
|
|
sphere_N = DictGer.bereich_N ;
|
|
spherical_A = DictGer.kugelfoermig_A ;
|
|
spice_N = DictGer.gewuerz_N ;
|
|
spicy_A = DictGer.pikant_A ;
|
|
spider_N = DictGer.spinne_N ;
|
|
spike_N = DictGer.nagel_N ;
|
|
spill_V = DictGer.schuetten_V ;
|
|
spill_V2 = P.dirV2 (DictGer.schuetten_V) ;
|
|
spinach_N = DictGer.spinat_N ;
|
|
spindle_N = DictGer.spindel_N ;
|
|
spine_N = DictGer.dorn_N ;
|
|
spinet_N = DictGer.spinett_N ;
|
|
spirit_N = DictGer.alkohol_N ;
|
|
spiritual_A = DictGer.geistig_A ;
|
|
spit_N = DictGer.nehrung_N ;
|
|
spit_V = LexiconGer.spit_V ;
|
|
spiteful_A = DictGer.boshaft_A ;
|
|
spittle_N = DictGer.spucke_N ;
|
|
spleen_N = DictGer.milz_N ;
|
|
splendid_A = DictGer.glaenzend_A ;
|
|
splint_N = DictGer.schiene_N ;
|
|
splinter_N = DictGer.splitter_N ;
|
|
split_V2 = LexiconGer.split_V2 ;
|
|
spoil_V = DictGer.ruinieren_V ;
|
|
spoil_V2 = P.dirV2 (DictGer.ruinieren_V) ;
|
|
spoilsport_N = DictGer.spielverderber_N ;
|
|
spoke_N = DictGer.speiche_N ;
|
|
sponge_N = DictGer.schnorrer_N ;
|
|
sponger_N = DictGer.schnorrer_N ;
|
|
spongy_A = DictGer.schwammig_A ;
|
|
spontaneous_A = DictGer.spontan_A ;
|
|
spoon_N = DictGer.loeffel_N ;
|
|
sporadic_A = DictGer.sporadisch_A ;
|
|
sportsman_N = DictGer.sportler_N ;
|
|
spot_N = DictGer.fleck_N ;
|
|
spotlight_N = DictGer.scheinwerfer_N ;
|
|
spouse_N = DictGer.ehepartner_N ;
|
|
sprain_N = DictGer.verstauchung_N ;
|
|
sprawl_V = DictGer.graetschen_V ;
|
|
sprawl_V2 = P.dirV2 (DictGer.graetschen_V) ;
|
|
spray_N = DictGer.spray_N ;
|
|
spread_V = DictGer.spreizen_V ;
|
|
spread_V2 = P.dirV2 (DictGer.spreizen_V) ;
|
|
spring_V = DictGer.springen_7_V ;
|
|
spring_V2 = P.dirV2 (DictGer.springen_7_V) ;
|
|
sprinkle_V2 = P.dirV2 (DictGer.bespruehen_V) ;
|
|
sprint_N = DictGer.sprint_N ;
|
|
sprite_N = DictGer.gruenspecht_N ;
|
|
spruce_N = DictGer.fichte_N ;
|
|
spud_N = DictGer.kartoffel_N ;
|
|
spunk_N = DictGer.saft_N ;
|
|
spurn_V2 = P.dirV2 (DictGer.verschmaehen_V) ;
|
|
spy_N = DictGer.spion_N ;
|
|
spyglass_N = DictGer.fernglas_N ;
|
|
squander_V2 = P.dirV2 (DictGer.vergeuden_V) ;
|
|
square_N = DictGer.doppelkreuz_N ;
|
|
squatter_N = DictGer.hausbesetzer_N ;
|
|
squeamish_A = DictGer.empfindlich_A ;
|
|
squeeze_V = DictGer.druecken_4_V ;
|
|
squeeze_V2 = LexiconGer.squeeze_V2 ;
|
|
squint_V = DictGer.blinzeln_6_V ;
|
|
squire_N = DictGer.galan_N ;
|
|
squirrel_N = DictGer.eichhoernchen_N ;
|
|
stab_V2 = LexiconGer.stab_V2 ;
|
|
stabilization_N = DictGer.stabilisierung_N ;
|
|
stabilize_V = DictGer.stabilisieren_V ;
|
|
stabilize_V2 = P.dirV2 (DictGer.stabilisieren_V) ;
|
|
stabilizer_N = DictGer.stabilisator_N ;
|
|
stable_N = DictGer.pferdestall_N ;
|
|
stack_N = DictGer.stapel_N ;
|
|
stadium_N = DictGer.stadion_N ;
|
|
staff_N = DictGer.belegschaft_N ;
|
|
stage_N = DictGer.buehne_N ;
|
|
stagflation_N = DictGer.stagflation_N ;
|
|
stagnate_V = DictGer.stagnieren_V ;
|
|
stagnation_N = DictGer.stagnation_N ;
|
|
staid_A = DictGer.gesetzt_A ;
|
|
stain_N = DictGer.fleck_N ;
|
|
stainless_A = DictGer.rostfrei_A ;
|
|
stair_N = DictGer.stufe_N ;
|
|
staircase_N = DictGer.treppe_N ;
|
|
stake_N = DictGer.pfahl_N ;
|
|
stale_A = DictGer.schal_A ;
|
|
stalemate_N = DictGer.patt_N ;
|
|
stalker_N = DictGer.stalker_N ;
|
|
stall_N = DictGer.bude_N ;
|
|
stallion_N = DictGer.beschaeler_N ;
|
|
stalwart_A = DictGer.handfest_A ;
|
|
stammer_V = DictGer.stammeln_V ;
|
|
stammer_V2 = P.dirV2 (DictGer.stammeln_V) ;
|
|
stamp_N = DictGer.stempel_N ;
|
|
stanchion_N = DictGer.pfosten_N ;
|
|
stand_V = LexiconGer.stand_V ;
|
|
stand_V2 = P.dirV2 (DictGer.kandidieren_V) ;
|
|
standard_N = DictGer.banner_N ;
|
|
standby_N = DictGer.bereitschaft_N ;
|
|
standpoint_N = DictGer.standpunkt_N ;
|
|
standstill_N = DictGer.stillstand_N ;
|
|
stanza_N = DictGer.strophe_N ;
|
|
staple_N = DictGer.ausgangsmaterial_N ;
|
|
stapler_N = DictGer.heftgeraet_N ;
|
|
star_N = LexiconGer.star_N ;
|
|
starboard_N = DictGer.steuerbord_N ;
|
|
starch_N = DictGer.staerke_N ;
|
|
stare_V = DictGer.starren_0_V ;
|
|
stare_V2 = P.dirV2 (DictGer.starren_0_V) ;
|
|
starfish_N = DictGer.seestern_N ;
|
|
starkers_A = DictGer.splitternackt_A ;
|
|
starling_N = DictGer.star_N ;
|
|
starry_A = DictGer.gestirnt_A ;
|
|
start_N = DictGer.beginn_N ;
|
|
starter_N = DictGer.vorspeise_N ;
|
|
state_N = DictGer.staat_N ;
|
|
statesman_N = DictGer.staatsmann_N ;
|
|
station_N = DictGer.bahnhof_N ;
|
|
stationery_N = DictGer.bueromaterial_N ;
|
|
statistical_A = DictGer.statistisch_A ;
|
|
statistics_N = DictGer.statistik_N ;
|
|
statue_N = DictGer.statue_N ;
|
|
status_N = DictGer.stand_N ;
|
|
stave_N = DictGer.daube_N ;
|
|
steady_A = DictGer.stetig_A ;
|
|
steak_N = DictGer.schnitte_N ;
|
|
steal_V = DictGer.rauben_V ;
|
|
steal_V2 = P.dirV2 (DictGer.rauben_V) ;
|
|
stealthy_A = DictGer.geheim_A ;
|
|
steam_N = DictGer.dampf_N ;
|
|
steamboat_N = DictGer.dampfer_N ;
|
|
steamer_N = DictGer.dampfer_N ;
|
|
steamship_N = DictGer.dampfer_N ;
|
|
steel_N = LexiconGer.steel_N ;
|
|
steelyard_N = DictGer.balkenwaage_N ;
|
|
steep_A = DictGer.steil_A ;
|
|
steeple_N = DictGer.kirchturm_N ;
|
|
stem_N = DictGer.stamm_N ;
|
|
stencil_N = DictGer.schablone_N ;
|
|
stepbrother_N = DictGer.stiefbruder_N ;
|
|
stepchild_N = DictGer.stiefkind_N ;
|
|
stepdaughter_N = DictGer.stieftochter_N ;
|
|
stepfather_N = DictGer.stiefvater_N ;
|
|
stepmother_N = DictGer.stiefmutter_N ;
|
|
stepparent_N = DictGer.stiefmutter_N ;
|
|
steppe_N = DictGer.steppe_N ;
|
|
stepsister_N = DictGer.stiefschwester_N ;
|
|
stepson_N = DictGer.stiefsohn_N ;
|
|
stereotype_N = DictGer.stereotyp_N ;
|
|
sterile_A = DictGer.steril_A ;
|
|
sterilize_V = DictGer.entkeimen_V ;
|
|
sterilize_V2 = P.dirV2 (DictGer.entkeimen_V) ;
|
|
stern_A = DictGer.streng_A ;
|
|
stethoscope_N = DictGer.stethoskop_N ;
|
|
stew_N = DictGer.brei_N ;
|
|
stewardess_N = DictGer.stewardess_N ;
|
|
stick_N = LexiconGer.stick_N ;
|
|
sticker_N = DictGer.aufkleber_N ;
|
|
stiff_A = DictGer.starr_A ;
|
|
stillness_N = DictGer.stille_N ;
|
|
stimulate_V2 = P.dirV2 (DictGer.stimulieren_V) ;
|
|
stimulation_N = DictGer.anregung_N ;
|
|
stimulus_N = DictGer.stimulus_N ;
|
|
sting_N = DictGer.stich_N ;
|
|
stinger_N = DictGer.stachel_N ;
|
|
stingy_A = DictGer.geizig_A ;
|
|
stink_V = DictGer.stinken_V ;
|
|
stink_V2 = P.dirV2 (DictGer.stinken_V) ;
|
|
stipend_N = DictGer.besoldung_N ;
|
|
stipulate_V = DictGer.stipulieren_V ;
|
|
stipulate_V2 = P.dirV2 (DictGer.stipulieren_V) ;
|
|
stipulation_N = DictGer.abmachung_N ;
|
|
stir_V = DictGer.bewegen_V ;
|
|
stir_V2 = P.dirV2 (DictGer.bewegen_V) ;
|
|
stirrup_N = DictGer.steigbuegel_N ;
|
|
stitch_N = DictGer.masche_N ;
|
|
stoat_N = DictGer.hermelin_N ;
|
|
stochastic_A = DictGer.stochastisch_A ;
|
|
stock_N = DictGer.aktie_N ;
|
|
stockfish_N = DictGer.stockfisch_N ;
|
|
stockholder_N = DictGer.aktionaer_N ;
|
|
stocking_N = DictGer.strumpf_N ;
|
|
stoic_N = DictGer.stoiker_N ;
|
|
stomach_N = DictGer.bauch_N ;
|
|
stomp_V = DictGer.stampfen_V ;
|
|
stomp_V2 = P.dirV2 (DictGer.stampfen_V) ;
|
|
stone_N = LexiconGer.stone_N ;
|
|
stonemason_N = DictGer.steinmetz_N ;
|
|
stony_A = DictGer.steinern_A ;
|
|
stooge_N = DictGer.spion_N ;
|
|
stool_N = DictGer.exkrement_N ;
|
|
stop_V = LexiconGer.stop_V ;
|
|
stop_V2 = P.dirV2 (DictGer.beenden_V) ;
|
|
stopwatch_N = DictGer.stoppuhr_N ;
|
|
store_N = DictGer.speicher_N ;
|
|
storey_N = DictGer.etage_N ;
|
|
stork_N = DictGer.storch_N ;
|
|
storm_N = DictGer.sturm_N ;
|
|
story_N = DictGer.erzaehlung_N ;
|
|
stove_N = LexiconGer.stove_N ;
|
|
straddle_V = DictGer.graetschen_V ;
|
|
straddle_V2 = P.dirV2 (DictGer.graetschen_V) ;
|
|
straight_A = LexiconGer.straight_A ;
|
|
straightforward_A = DictGer.aufrichtig_A ;
|
|
strain_N = DictGer.stamm_N ;
|
|
straitjacket_N = DictGer.zwangsjacke_N ;
|
|
strand_N = DictGer.strand_N ;
|
|
strange_A = DictGer.komisch_A ;
|
|
strangle_V2 = P.dirV2 (DictGer.strangulieren_V) ;
|
|
strategic_A = DictGer.strategisch_A ;
|
|
strategy_N = DictGer.strategie_N ;
|
|
straw_N = DictGer.halm_N ;
|
|
strawberry_N = DictGer.erdbeere_N ;
|
|
stream_N = DictGer.bach_N ;
|
|
street_N = DictGer.strasse_N ;
|
|
streetwalker_N = DictGer.strichmaedchen_N ;
|
|
strength_N = DictGer.kraft_N ;
|
|
strengthen_V = DictGer.bestaerken_V ;
|
|
strengthen_V2 = P.dirV2 (DictGer.bestaerken_V) ;
|
|
strenuous_A = DictGer.anstrengend_A ;
|
|
stress_N = DictGer.betonung_N ;
|
|
stretch_V = DictGer.strecken_6_V ;
|
|
stretch_V2 = P.dirV2 (DictGer.strecken_6_V) ;
|
|
strew_V2 = P.dirV2 (DictGer.streuen_V) ;
|
|
strict_A = DictGer.streng_A ;
|
|
strife_N = DictGer.streit_N ;
|
|
strike_V = DictGer.scheinen_6_V ;
|
|
strike_V2 = P.dirV2 (DictGer.scheinen_6_V) ;
|
|
strikebreaker_N = DictGer.streikbrecher_N ;
|
|
striking_A = DictGer.auffaellig_A ;
|
|
string_N = DictGer.saite_N ;
|
|
stripe_N = DictGer.streifen_N ;
|
|
striped_A = DictGer.gestreift_A ;
|
|
stripling_N = DictGer.juengling_N ;
|
|
stripper_N = DictGer.stripper_N ;
|
|
strive_V = DictGer.streben_6_V ;
|
|
stroboscope_N = DictGer.stroboskop_N ;
|
|
stroke_N = DictGer.apoplexy_N ;
|
|
stroller_N = DictGer.kinderwagen_N ;
|
|
strong_A = DictGer.stark_A ;
|
|
stronghold_N = DictGer.festung_N ;
|
|
strop_N = DictGer.riemen_N ;
|
|
structure_N = DictGer.struktur_N ;
|
|
strudel_N = DictGer.strudel_N ;
|
|
struggle_N = DictGer.kampf_N ;
|
|
strum_V = DictGer.schrammeln_V ;
|
|
strum_V2 = P.dirV2 (DictGer.schrammeln_V) ;
|
|
strumpet_N = DictGer.dirne_N ;
|
|
stub_N = DictGer.abriss_N ;
|
|
stubborn_A = DictGer.stur_A ;
|
|
stubbornness_N = DictGer.sturheit_N ;
|
|
stucco_N = DictGer.stuck_N ;
|
|
student_N = LexiconGer.student_N ;
|
|
studio_N = DictGer.atelier_N ;
|
|
study_V = DictGer.lernen_4_V ;
|
|
study_V2 = P.dirV2 (DictGer.lernen_4_V) ;
|
|
stuff_N = DictGer.stoff_N ;
|
|
stuffy_A = DictGer.stickig_A ;
|
|
stumble_N = DictGer.fehler_N ;
|
|
stump_N = DictGer.stumpf_N ;
|
|
stupid_A = LexiconGer.stupid_A ;
|
|
stupidity_N = DictGer.dummheit_N ;
|
|
sturdy_A = DictGer.robust_A ;
|
|
sturgeon_N = DictGer.stoer_N ;
|
|
stutter_V = DictGer.stammeln_V ;
|
|
stutter_V2 = P.dirV2 (DictGer.stammeln_V) ;
|
|
stye_N = DictGer.gerstenkorn_N ;
|
|
style_N = DictGer.stil_N ;
|
|
stylish_A = DictGer.elegant_A ;
|
|
suave_A = DictGer.mild_A ;
|
|
subcontinent_N = DictGer.subkontinent_N ;
|
|
sublimate_V2 = P.dirV2 (DictGer.sublimieren_V) ;
|
|
sublimation_N = DictGer.sublimation_N ;
|
|
sublime_A = DictGer.erhaben_A ;
|
|
submersion_N = DictGer.submersion_N ;
|
|
suborbital_A = DictGer.suborbital_A ;
|
|
subscribe_V = DictGer.abonnieren_V ;
|
|
subscribe_V2 = P.dirV2 (DictGer.abonnieren_V) ;
|
|
subscriber_N = DictGer.abonnent_N ;
|
|
subscription_N = DictGer.abonnement_N ;
|
|
subsequent_A = DictGer.anschliessend_A ;
|
|
subsidiary_A = DictGer.ergaenzend_A ;
|
|
subsidize_V2 = P.dirV2 (DictGer.subventionieren_V) ;
|
|
subsidy_N = DictGer.subvention_N ;
|
|
subsoil_N = DictGer.untergrund_N ;
|
|
substance_N = DictGer.stoff_N ;
|
|
substitute_V = DictGer.ersetzen_V ;
|
|
substitute_V2 = P.dirV2 (DictGer.ersetzen_V) ;
|
|
substitution_N = DictGer.ersatz_N ;
|
|
substrate_N = DictGer.substrat_N ;
|
|
subsume_V2 = P.dirV2 (DictGer.fassen_0_V) ;
|
|
subterfuge_N = DictGer.list_N ;
|
|
subterranean_A = DictGer.unterirdisch_A ;
|
|
subtitle_N = DictGer.untertitel_N ;
|
|
subtle_A = DictGer.dezent_A ;
|
|
subtlety_N = DictGer.feinheit_N ;
|
|
subtract_V2 = P.dirV2 (DictGer.subtrahieren_V) ;
|
|
subtraction_N = DictGer.subtraktion_N ;
|
|
subversion_N = DictGer.subversion_N ;
|
|
subversive_A = DictGer.subversiv_A ;
|
|
subway_N = DictGer.untergrundbahn_N ;
|
|
success_N = DictGer.erfolg_N ;
|
|
successful_A = DictGer.erfolgreich_A ;
|
|
succession_N = DictGer.abfolge_N ;
|
|
successor_N = DictGer.nachfolger_N ;
|
|
succinct_A = DictGer.buendig_A ;
|
|
suck_V = DictGer.saugen_7_V ;
|
|
suck_V2 = LexiconGer.suck_V2 ;
|
|
suckling_N = DictGer.saeugling_N ;
|
|
sudden_A = DictGer.jaeh_A ;
|
|
suede_N = DictGer.wildleder_N ;
|
|
suffer_V = DictGer.erleiden_V ;
|
|
suffer_V2 = P.dirV2 (DictGer.erleiden_V) ;
|
|
suffice_V = DictGer.befriedigen_V ;
|
|
suffice_V2 = P.dirV2 (DictGer.befriedigen_V) ;
|
|
suffix_N = DictGer.nachsilbe_N ;
|
|
suffocate_V = DictGer.ersticken_V ;
|
|
suffocate_V2 = P.dirV2 (DictGer.ersticken_V) ;
|
|
suffrage_N = DictGer.wahlrecht_N ;
|
|
sugar_N = DictGer.scheibenkleister_N ;
|
|
suggestion_N = DictGer.suggestion_N ;
|
|
suggestive_A = DictGer.suggestiv_A ;
|
|
suicide_N = DictGer.freitod_N ;
|
|
suit_N = DictGer.anzug_N ;
|
|
suitable_A = DictGer.geeignet_A ;
|
|
suitcase_N = DictGer.koffer_N ;
|
|
sully_V2 = P.dirV2 (DictGer.besudeln_V) ;
|
|
sultan_N = DictGer.sultan_N ;
|
|
sultry_A = DictGer.schwuel_A ;
|
|
sum_N = DictGer.summe_N ;
|
|
summer_N = DictGer.sommer_N ;
|
|
summery_A = DictGer.sommerlich_A ;
|
|
summit_N = DictGer.gipfel_N ;
|
|
summon_V2 = P.dirV2 (DictGer.beschwoeren_V) ;
|
|
summons_N = DictGer.aufforderung_N ;
|
|
sumptuous_A = DictGer.praechtig_A ;
|
|
sun_N = LexiconGer.sun_N ;
|
|
sunday_N = DictGer.sonntag_N ;
|
|
sundial_N = DictGer.sonnenuhr_N ;
|
|
sunflower_N = DictGer.sonnenblume_N ;
|
|
sunny_A = DictGer.sonnig_A ;
|
|
sunrise_N = DictGer.sonnenaufgang_N ;
|
|
sunroof_N = DictGer.schiebedach_N ;
|
|
sunset_N = DictGer.lebensabend_N ;
|
|
sunshade_N = DictGer.sonnenschirm_N ;
|
|
sunstroke_N = DictGer.sonnenstich_N ;
|
|
suntan_N = DictGer.braeune_N ;
|
|
superb_A = DictGer.grossartig_A ;
|
|
supercilious_A = DictGer.anmassend_A ;
|
|
superficial_A = DictGer.oberflaechlich_A ;
|
|
superficiality_N = DictGer.oberflaechlichkeit_N ;
|
|
superfluous_A = DictGer.ueberfluessig_A ;
|
|
superlative_N = DictGer.superlativ_N ;
|
|
superman_N = DictGer.uebermensch_N ;
|
|
supermarket_N = DictGer.supermarkt_N ;
|
|
supersede_V2 = P.dirV2 (DictGer.ersetzen_V) ;
|
|
superstitious_A = DictGer.aberglaeubisch_A ;
|
|
supervision_N = DictGer.aufsicht_N ;
|
|
supervisor_N = DictGer.aufseher_N ;
|
|
supper_N = DictGer.abendessen_N ;
|
|
supplant_V2 = P.dirV2 (DictGer.ersetzen_V) ;
|
|
supplementary_A = DictGer.zusaetzlich_A ;
|
|
supplier_N = DictGer.lieferant_N ;
|
|
supply_V2 = P.dirV2 (DictGer.liefern_4_V) ;
|
|
support_N = DictGer.stuetze_N ;
|
|
suppose_V2 = P.dirV2 (DictGer.vermuten_V) ;
|
|
suppository_N = DictGer.zaepfchen_N ;
|
|
suppress_V2 = P.dirV2 (DictGer.unterdruecken_V) ;
|
|
suppurate_V = DictGer.eitern_V ;
|
|
surcharge_N = DictGer.aufpreis_N ;
|
|
surf_N = DictGer.brandung_N ;
|
|
surface_N = DictGer.oberflaeche_N ;
|
|
surge_N = DictGer.brandung_N ;
|
|
surgeon_N = DictGer.chirurg_N ;
|
|
surgery_N = DictGer.chirurgie_N ;
|
|
surgical_A = DictGer.chirurgisch_A ;
|
|
surmount_V2 = P.dirV2 (DictGer.ueberwinden_V) ;
|
|
surname_N = DictGer.familienname_N ;
|
|
surpass_V2 = P.dirV2 (DictGer.uebersteigen_V) ;
|
|
surplus_N = DictGer.ueberschuss_N ;
|
|
surprise_N = DictGer.ueberraschung_N ;
|
|
surprised_A = DictGer.ueberrascht_A ;
|
|
surrender_V = DictGer.kapitulieren_V ;
|
|
surrender_V2 = P.dirV2 (DictGer.kapitulieren_V) ;
|
|
surreptitious_A = DictGer.heimlich_A ;
|
|
surround_V2 = P.dirV2 (DictGer.umgeben_V) ;
|
|
surveillance_N = DictGer.ueberwachung_N ;
|
|
survive_V = DictGer.ueberleben_V ;
|
|
survive_V2 = P.dirV2 (DictGer.ueberleben_V) ;
|
|
susceptible_A = DictGer.anfaellig_A ;
|
|
suspect_V2 = P.dirV2 (DictGer.misstrauen_V) ;
|
|
suspender_N = DictGer.hosentraeger_N ;
|
|
suspense_N = DictGer.anspannung_N ;
|
|
suspicious_A = DictGer.verdaechtig_A ;
|
|
suture_N = DictGer.naht_N ;
|
|
swaddle_V2 = P.dirV2 (DictGer.wickeln_7_V) ;
|
|
swallow_V = DictGer.schlucken_V ;
|
|
swallow_V2 = P.dirV2 (DictGer.schlucken_V) ;
|
|
swamp_N = DictGer.moor_N ;
|
|
swan_N = DictGer.schwaenin_N ;
|
|
swarm_N = DictGer.schwarm_N ;
|
|
swashbuckling_A = DictGer.verwegen_A ;
|
|
swastika_N = DictGer.hakenkreuz_N ;
|
|
swath_N = DictGer.schneise_N ;
|
|
swathe_N = DictGer.bandage_N ;
|
|
sweater_N = DictGer.pullover_N ;
|
|
swede_N = DictGer.schwede_N ;
|
|
sweep_V = DictGer.fegen_7_V ;
|
|
sweep_V2 = P.dirV2 (DictGer.fegen_7_V) ;
|
|
sweet_A = DictGer.lecker_A ;
|
|
sweeten_V = DictGer.suessen_V ;
|
|
sweeten_V2 = P.dirV2 (DictGer.suessen_V) ;
|
|
sweetheart_N = DictGer.liebling_N ;
|
|
sweetish_A = DictGer.suesslich_A ;
|
|
sweetness_N = DictGer.suessigkeit_N ;
|
|
swell_A = DictGer.klasse_A ;
|
|
swell_V = LexiconGer.swell_V ;
|
|
swift_A = DictGer.schnell_A ;
|
|
swim_V = LexiconGer.swim_V ;
|
|
swim_V2 = P.dirV2 (DictGer.schwimmen_V) ;
|
|
swimsuit_N = DictGer.badeanzug_N ;
|
|
swindle_V = DictGer.beschwindeln_V ;
|
|
swindle_V2 = P.dirV2 (DictGer.beschwindeln_V) ;
|
|
swindler_N = DictGer.betrueger_N ;
|
|
swine_N = DictGer.schwein_N ;
|
|
swing_N = DictGer.schaukel_N ;
|
|
swipe_V2 = P.dirV2 (DictGer.klauen_V) ;
|
|
switch_N = DictGer.schalter_N ;
|
|
swoon_N = DictGer.ohnmacht_N ;
|
|
sword_N = DictGer.schwert_N ;
|
|
swordfish_N = DictGer.schwertfisch_N ;
|
|
swot_V = DictGer.bueffeln_V ;
|
|
swot_V2 = P.dirV2 (DictGer.bueffeln_V) ;
|
|
sycamore_N = DictGer.ahorn_N ;
|
|
syllabification_N = DictGer.silbentrennung_N ;
|
|
syllable_N = DictGer.silbe_N ;
|
|
syllogism_N = DictGer.syllogismus_N ;
|
|
symbiosis_N = DictGer.symbiose_N ;
|
|
symbol_N = DictGer.symbol_N ;
|
|
symbolic_A = DictGer.symbolisch_A ;
|
|
symmetrical_A = DictGer.symmetrisch_A ;
|
|
symmetry_N = DictGer.symmetrie_N ;
|
|
sympathy_N = DictGer.sympathie_N ;
|
|
symphony_N = DictGer.sinfonie_N ;
|
|
symptom_N = DictGer.symptom_N ;
|
|
synagogue_N = DictGer.synagoge_N ;
|
|
synchronous_A = DictGer.synchron_A ;
|
|
syncope_N = DictGer.synkope_N ;
|
|
syndrome_N = DictGer.syndrom_N ;
|
|
synonymous_A = DictGer.synonym_A ;
|
|
synopsis_N = DictGer.synopse_N ;
|
|
syntax_N = DictGer.syntax_N ;
|
|
synthesis_N = DictGer.synthese_N ;
|
|
synthesize_V2 = P.dirV2 (DictGer.synthetisieren_V) ;
|
|
synthetic_A = DictGer.synthetisch_A ;
|
|
syringe_N = DictGer.spritze_N ;
|
|
syrup_N = DictGer.sirup_N ;
|
|
systematic_A = DictGer.systematisch_A ;
|
|
systematize_V2 = P.dirV2 (DictGer.systematisieren_V) ;
|
|
tab_N = DictGer.reiter_N ;
|
|
tabernacle_N = DictGer.stiftshuette_N ;
|
|
table_N = LexiconGer.table_N ;
|
|
tablespoon_N = DictGer.essloeffel_N ;
|
|
tableware_N = DictGer.geschirr_N ;
|
|
taboo_N = DictGer.tabu_N ;
|
|
tabular_A = DictGer.tabellarisch_A ;
|
|
tacit_A = DictGer.stillschweigend_A ;
|
|
tacky_A = DictGer.billig_A ;
|
|
tact_N = DictGer.takt_N ;
|
|
tactic_N = DictGer.taktik_N ;
|
|
tactical_A = DictGer.taktisch_A ;
|
|
tactile_A = DictGer.taktil_A ;
|
|
tactless_A = DictGer.taktlos_A ;
|
|
tadpole_N = DictGer.kaulquappe_N ;
|
|
tag_N = DictGer.marke_N ;
|
|
tail_N = LexiconGer.tail_N ;
|
|
tailor_N = DictGer.schneider_N ;
|
|
take_V = DictGer.dauern_7_V ;
|
|
take_V2 = P.dirV2 (DictGer.dauern_7_V) ;
|
|
talc_N = DictGer.talc_N ;
|
|
talcum_N = DictGer.talc_N ;
|
|
tale_N = DictGer.erzaehlung_N ;
|
|
talent_N = DictGer.begabung_N ;
|
|
talented_A = DictGer.begabt_A ;
|
|
talisman_N = DictGer.talisman_N ;
|
|
talk_N = DictGer.gespraech_N ;
|
|
talkative_A = DictGer.redselig_A ;
|
|
tamarind_N = DictGer.tamarinde_N ;
|
|
tamarisk_N = DictGer.tamariske_N ;
|
|
tame_A = DictGer.zahm_A ;
|
|
tamer_N = DictGer.dompteur_N ;
|
|
tangent_N = DictGer.tangens_N ;
|
|
tangerine_N = DictGer.mandarine_N ;
|
|
tangible_A = DictGer.greifbar_A ;
|
|
tangle_V = DictGer.verwirren_V ;
|
|
tangle_V2 = P.dirV2 (DictGer.verwirren_V) ;
|
|
tango_N = DictGer.tango_N ;
|
|
tangy_A = DictGer.scharf_A ;
|
|
tank_N = DictGer.behaelter_N ;
|
|
tankard_N = DictGer.krug_N ;
|
|
tanker_N = DictGer.tanker_N ;
|
|
tannery_N = DictGer.gerberei_N ;
|
|
tannin_N = DictGer.tannin_N ;
|
|
tap_N = DictGer.gewindeschneider_N ;
|
|
tapeworm_N = DictGer.bandwurm_N ;
|
|
tapir_N = DictGer.tapir_N ;
|
|
tar_N = DictGer.teer_N ;
|
|
tarantula_N = DictGer.tarantel_N ;
|
|
tardy_A = DictGer.langsam_A ;
|
|
tare_N = DictGer.tara_N ;
|
|
target_N = DictGer.ziel_N ;
|
|
tarry_V = DictGer.verweilen_V ;
|
|
tart_A = DictGer.herb_A ;
|
|
task_N = DictGer.aufgabe_N ;
|
|
tassel_N = DictGer.quaste_N ;
|
|
tasteless_A = DictGer.geschmacklos_A ;
|
|
tasty_A = DictGer.koestlich_A ;
|
|
tattle_V = DictGer.klatschen_0_V ;
|
|
tattle_V2 = P.dirV2 (DictGer.klatschen_0_V) ;
|
|
taunt_V2 = P.dirV2 (DictGer.verspotten_V) ;
|
|
tautological_A = DictGer.tautologisch_A ;
|
|
tautology_N = DictGer.tautologie_N ;
|
|
tavern_N = DictGer.gasthaus_N ;
|
|
tax_N = DictGer.steuer_N ;
|
|
taxi_N = DictGer.taxe_N ;
|
|
taxonomy_N = DictGer.taxonomie_N ;
|
|
taxpayer_N = DictGer.steuerzahler_N ;
|
|
tea_N = DictGer.tee_N ;
|
|
teach_V = DictGer.lehren_V ;
|
|
teach_V2 = LexiconGer.teach_V2 ;
|
|
teacher_N = LexiconGer.teacher_N ;
|
|
teaching_N = DictGer.lehre_N ;
|
|
teacup_N = DictGer.teetasse_N ;
|
|
team_N = DictGer.mannschaft_N ;
|
|
teapot_N = DictGer.teekanne_N ;
|
|
tear_V = DictGer.reissen_9_V ;
|
|
tear_V2 = P.dirV2 (DictGer.reissen_9_V) ;
|
|
teasel_N = DictGer.karde_N ;
|
|
teaspoon_N = DictGer.teeloeffel_N ;
|
|
teat_N = DictGer.brustwarze_N ;
|
|
technical_A = DictGer.fachlich_A ;
|
|
technique_N = DictGer.technik_N ;
|
|
technology_N = DictGer.technik_N ;
|
|
teetotaller_N = DictGer.abstinenzler_N ;
|
|
telegram_N = DictGer.telegramm_N ;
|
|
telephone_N = DictGer.fernsprecher_N ;
|
|
telescope_N = DictGer.fernrohr_N ;
|
|
television_N = LexiconGer.television_N ;
|
|
tell_V = DictGer.erzaehlen_V ;
|
|
tell_V2 = P.dirV2 (DictGer.erzaehlen_V) ;
|
|
teller_N = DictGer.bankautomat_N ;
|
|
temper_N = DictGer.laune_N ;
|
|
temperament_N = DictGer.charakter_N ;
|
|
temperature_N = DictGer.temperatur_N ;
|
|
tempest_N = DictGer.sturm_N ;
|
|
template_N = DictGer.schablone_N ;
|
|
temple_N = DictGer.schlaefe_N ;
|
|
temporal_A = DictGer.temporaer_A ;
|
|
temporary_A = DictGer.temporaer_A ;
|
|
tempt_V2 = P.dirV2 (DictGer.locken_4_V) ;
|
|
tenable_A = DictGer.haltbar_A ;
|
|
tenacious_A = DictGer.beharrlich_A ;
|
|
tenant_N = DictGer.bewohner_N ;
|
|
tendentious_A = DictGer.tendenzioes_A ;
|
|
tender_A = DictGer.empfindlich_A ;
|
|
tenderness_N = DictGer.zaertlichkeit_N ;
|
|
tendon_N = DictGer.sehne_N ;
|
|
tendril_N = DictGer.ranke_N ;
|
|
tenement_N = DictGer.mietshaus_N ;
|
|
tenet_N = DictGer.grundregel_N ;
|
|
tenon_N = DictGer.zapfen_N ;
|
|
tense_N = DictGer.tempus_N ;
|
|
tension_N = DictGer.spannung_N ;
|
|
tent_N = DictGer.zelt_N ;
|
|
tenure_N = DictGer.bekleidung_N ;
|
|
tepid_A = DictGer.lauwarm_A ;
|
|
term_N = DictGer.begriff_N ;
|
|
terminology_N = DictGer.fachsprache_N ;
|
|
terrace_N = DictGer.terrasse_N ;
|
|
terrain_N = DictGer.terrain_N ;
|
|
terrific_A = DictGer.fantastisch_A ;
|
|
territory_N = DictGer.territorium_N ;
|
|
terror_N = DictGer.schrecken_N ;
|
|
terrorist_N = DictGer.terrorist_N ;
|
|
terse_A = DictGer.knapp_A ;
|
|
tertiary_A = DictGer.tertiaer_A ;
|
|
test_N = DictGer.probe_N ;
|
|
testament_N = DictGer.testament_N ;
|
|
testicle_N = DictGer.hoden_N ;
|
|
testimonial_N = DictGer.referenz_N ;
|
|
testimony_N = DictGer.zeugnis_N ;
|
|
tether_N = DictGer.strick_N ;
|
|
text_N = DictGer.text_N ;
|
|
textbook_N = DictGer.lehrbuch_N ;
|
|
textual_A = DictGer.textuell_A ;
|
|
thankful_A = DictGer.dankbar_A ;
|
|
theft_N = DictGer.diebstahl_N ;
|
|
thematic_A = DictGer.thematisch_A ;
|
|
theologian_N = DictGer.theologe_N ;
|
|
theological_A = DictGer.theologisch_A ;
|
|
theology_N = DictGer.theologie_N ;
|
|
theorem_N = DictGer.satz_N ;
|
|
theoretic_A = DictGer.theoretisch_A ;
|
|
theoretical_A = DictGer.theoretisch_A ;
|
|
theorist_N = DictGer.theoretiker_N ;
|
|
theory_N = DictGer.theorie_N ;
|
|
therapy_N = DictGer.therapie_N ;
|
|
thesis_N = DictGer.dissertation_N ;
|
|
thick_A = LexiconGer.thick_A ;
|
|
thicket_N = DictGer.dickicht_N ;
|
|
thickness_N = DictGer.dicke_N ;
|
|
thief_N = DictGer.dieb_N ;
|
|
thieve_V = DictGer.stehlen_V ;
|
|
thieve_V2 = P.dirV2 (DictGer.stehlen_V) ;
|
|
thigh_N = DictGer.oberschenkel_N ;
|
|
thighbone_N = DictGer.oberschenkelknochen_N ;
|
|
thimble_N = DictGer.fingerhut_N ;
|
|
thin_A = LexiconGer.thin_A ;
|
|
think_V = LexiconGer.think_V ;
|
|
think_V2 = P.dirV2 (DictGer.denken_0_V) ;
|
|
thinkable_A = DictGer.denkbar_A ;
|
|
thirsty_A = DictGer.durstig_A ;
|
|
thong_N = DictGer.string_N ;
|
|
thorn_N = DictGer.dorn_N ;
|
|
thorough_A = DictGer.gruendlich_A ;
|
|
thought_N = DictGer.gedanke_N ;
|
|
thread_N = DictGer.garn_N ;
|
|
threat_N = DictGer.drohung_N ;
|
|
threaten_V = DictGer.bedrohen_V ;
|
|
threaten_V2 = P.dirV2 (DictGer.bedrohen_V) ;
|
|
thresh_V = DictGer.dreschen_V ;
|
|
thresh_V2 = P.dirV2 (DictGer.dreschen_V) ;
|
|
threshold_N = DictGer.schwelle_N ;
|
|
thrift_N = DictGer.sparkasse_N ;
|
|
thrill_V = DictGer.erregen_V ;
|
|
thrill_V2 = P.dirV2 (DictGer.erregen_V) ;
|
|
thriller_N = DictGer.thriller_N ;
|
|
thrive_V = DictGer.bluehen_9_V ;
|
|
throat_N = DictGer.flaschenhals_N ;
|
|
throb_V = DictGer.klopfen_8_V ;
|
|
thrombosis_N = DictGer.thrombose_N ;
|
|
throne_N = DictGer.thron_N ;
|
|
throstle_N = DictGer.drossel_N ;
|
|
throttle_N = DictGer.gaspedal_N ;
|
|
throw_V = DictGer.werfen_6_V ;
|
|
throw_V2 = LexiconGer.throw_V2 ;
|
|
thrush_N = DictGer.drossel_N ;
|
|
thug_N = DictGer.rowdy_N ;
|
|
thumb_N = DictGer.daumen_N ;
|
|
thumbtack_N = DictGer.reissnagel_N ;
|
|
thunderstorm_N = DictGer.gewitter_N ;
|
|
thursday_N = DictGer.donnerstag_N ;
|
|
thwart_V2 = P.dirV2 (DictGer.entgegenwirken_V) ;
|
|
thyme_N = DictGer.thymian_N ;
|
|
tick_N = DictGer.zeck_N ;
|
|
ticket_N = DictGer.eintrittskarte_N ;
|
|
ticklish_A = DictGer.brenzlig_A ;
|
|
tie_V2 = LexiconGer.tie_V2 ;
|
|
tier_N = DictGer.etage_N ;
|
|
tiger_N = DictGer.tiger_N ;
|
|
tilde_N = DictGer.tilde_N ;
|
|
tile_N = DictGer.dachziegel_N ;
|
|
timber_N = DictGer.bauholz_N ;
|
|
timbre_N = DictGer.timbre_N ;
|
|
time_N = DictGer.mal_N ;
|
|
timid_A = DictGer.furchtsam_A ;
|
|
timothy_N = DictGer.lieschgras_N ;
|
|
tin_N = DictGer.backform_N ;
|
|
tincture_N = DictGer.tinktur_N ;
|
|
tine_N = DictGer.ende_N ;
|
|
tiny_A = DictGer.winzig_A ;
|
|
tip_N = DictGer.spitze_N ;
|
|
tirade_N = DictGer.tirade_N ;
|
|
tire_N = DictGer.reifen_N ;
|
|
tiredness_N = DictGer.fatigue_N ;
|
|
tissue_N = DictGer.gewebe_N ;
|
|
tit_N = DictGer.brust_N ;
|
|
tithe_N = DictGer.zehnt_N ;
|
|
title_N = DictGer.titel_N ;
|
|
toad_N = DictGer.kroete_N ;
|
|
toast_N = DictGer.trinkspruch_N ;
|
|
toaster_N = DictGer.toaster_N ;
|
|
tobacco_N = DictGer.tabak_N ;
|
|
toddler_N = DictGer.knirps_N ;
|
|
toe_N = DictGer.zeh_N ;
|
|
toenail_N = DictGer.zehennagel_N ;
|
|
toga_N = DictGer.toga_N ;
|
|
toilet_N = DictGer.klo_N ;
|
|
tolerable_A = DictGer.ertraeglich_A ;
|
|
tolerance_N = DictGer.toleranz_N ;
|
|
tolerant_A = DictGer.tolerant_A ;
|
|
tolerate_V2 = P.dirV2 (DictGer.dulden_V) ;
|
|
toll_N = DictGer.abgabe_N ;
|
|
tollgate_N = DictGer.schlagbaum_N ;
|
|
tomahawk_N = DictGer.tomahawk_N ;
|
|
tomato_N = DictGer.paradeiser_N ;
|
|
tombstone_N = DictGer.grabstein_N ;
|
|
tome_N = DictGer.waelzer_N ;
|
|
ton_N = DictGer.tonne_N ;
|
|
tone_N = DictGer.farbton_N ;
|
|
tongue_N = LexiconGer.tongue_N ;
|
|
tonne_N = DictGer.tonne_N ;
|
|
tonsil_N = DictGer.mandel_N ;
|
|
tonsillitis_N = DictGer.tonsillitis_N ;
|
|
tool_N = DictGer.geraet_N ;
|
|
tooth_N = LexiconGer.tooth_N ;
|
|
toothache_N = DictGer.zahnschmerz_N ;
|
|
toothbrush_N = DictGer.zahnbuerste_N ;
|
|
toothless_A = DictGer.zahnlos_A ;
|
|
toothpick_N = DictGer.zahnstocher_N ;
|
|
top_N = DictGer.deckel_N ;
|
|
torch_N = DictGer.fackel_N ;
|
|
toreador_N = DictGer.torero_N ;
|
|
torment_N = DictGer.qual_N ;
|
|
tormentor_N = DictGer.peiniger_N ;
|
|
tornado_N = DictGer.tornado_N ;
|
|
torpedo_N = DictGer.torpedo_N ;
|
|
torque_N = DictGer.drehmoment_N ;
|
|
torrent_N = DictGer.schwall_N ;
|
|
torrential_A = DictGer.sintflutartig_A ;
|
|
tortoise_N = DictGer.schildkroete_N ;
|
|
torture_N = DictGer.folter_N ;
|
|
total_N = DictGer.summe_N ;
|
|
totem_N = DictGer.totem_N ;
|
|
toucan_N = DictGer.tukan_N ;
|
|
touch_V = DictGer.beruehren_V ;
|
|
touch_V2 = P.dirV2 (DictGer.beruehren_V) ;
|
|
touched_A = DictGer.bewegt_A ;
|
|
touchy_A = DictGer.heikel_A ;
|
|
tough_A = DictGer.zaeh_A ;
|
|
toupee_N = DictGer.toupet_N ;
|
|
tour_N = DictGer.reise_N ;
|
|
tournament_N = DictGer.turnier_N ;
|
|
tow_V2 = P.dirV2 (DictGer.schleppen_0_V) ;
|
|
towel_N = DictGer.handtuch_N ;
|
|
tower_N = DictGer.turm_N ;
|
|
town_N = DictGer.gemeinde_N ;
|
|
toxic_A = DictGer.giftig_A ;
|
|
toxin_N = DictGer.toxin_N ;
|
|
toy_N = DictGer.spielzeug_N ;
|
|
traceable_A = DictGer.nachvollziehbar_A ;
|
|
track_N = DictGer.fussspur_N ;
|
|
tract_N = DictGer.gebiet_N ;
|
|
tractor_N = DictGer.schlepper_N ;
|
|
trade_N = DictGer.handwerk_N ;
|
|
tradition_N = DictGer.tradition_N ;
|
|
traditional_A = DictGer.traditionell_A ;
|
|
traffic_N = DictGer.verkehr_N ;
|
|
tragedy_N = DictGer.tragoedie_N ;
|
|
tragic_A = DictGer.tragisch_A ;
|
|
trailer_N = DictGer.anhaenger_N ;
|
|
train_N = LexiconGer.train_N ;
|
|
trainee_N = DictGer.praktikant_N ;
|
|
trainer_N = DictGer.trainer_N ;
|
|
trait_N = DictGer.eigenschaft_N ;
|
|
traitor_N = DictGer.verraeter_N ;
|
|
trajectory_N = DictGer.bahn_N ;
|
|
tram_N = DictGer.strassenbahn_N ;
|
|
tramp_N = DictGer.flittchen_N ;
|
|
trance_N = DictGer.trance_N ;
|
|
tranquil_A = DictGer.ruhig_A ;
|
|
transaction_N = DictGer.geschaeft_N ;
|
|
transcontinental_A = DictGer.transkontinental_A ;
|
|
transcribe_V2 = P.dirV2 (DictGer.transkribieren_V) ;
|
|
transcription_N = DictGer.transkription_N ;
|
|
transfer_V = DictGer.uebertragen_V ;
|
|
transfer_V2 = P.dirV2 (DictGer.uebertragen_V) ;
|
|
transform_V2 = P.dirV2 (DictGer.transformieren_V) ;
|
|
transformation_N = DictGer.transformation_N ;
|
|
transformer_N = DictGer.transformator_N ;
|
|
transfusion_N = DictGer.bluttransfusion_N ;
|
|
transient_A = DictGer.kurzlebig_A ;
|
|
transistor_N = DictGer.transistor_N ;
|
|
transition_N = DictGer.uebergang_N ;
|
|
transitional_A = DictGer.vorlaeufig_A ;
|
|
transitive_A = DictGer.transitiv_A ;
|
|
transitory_A = DictGer.fluechtig_A ;
|
|
translate_V = DictGer.uebersetzen_V ;
|
|
translate_V2 = P.dirV2 (DictGer.uebersetzen_V) ;
|
|
translation_N = DictGer.translation_N ;
|
|
translator_N = DictGer.uebersetzer_N ;
|
|
transliteration_N = DictGer.transkription_N ;
|
|
translucent_A = DictGer.lichtdurchlaessig_A ;
|
|
transmission_N = DictGer.getriebe_N ;
|
|
transmitter_N = DictGer.sender_N ;
|
|
transmogrify_V2 = P.dirV2 (DictGer.transformieren_V) ;
|
|
transparency_N = DictGer.transparenz_N ;
|
|
transparent_A = DictGer.durchsichtig_A ;
|
|
transplant_V = DictGer.transplantieren_V ;
|
|
transplant_V2 = P.dirV2 (DictGer.transplantieren_V) ;
|
|
transplantation_N = DictGer.transplantation_N ;
|
|
transport_V2 = P.dirV2 (DictGer.befoerdern_V) ;
|
|
trap_N = DictGer.falle_N ;
|
|
trapezium_N = DictGer.trapez_N ;
|
|
trapezoid_N = DictGer.trapez_N ;
|
|
trash_N = DictGer.abfall_N ;
|
|
trauma_N = DictGer.trauma_N ;
|
|
traumatic_A = DictGer.traumatisch_A ;
|
|
travel_V = LexiconGer.travel_V ;
|
|
travel_V2 = P.dirV2 (DictGer.reisen_3_V) ;
|
|
tray_N = DictGer.tablett_N ;
|
|
treacle_N = DictGer.melasse_N ;
|
|
tread_N = DictGer.profil_N ;
|
|
treadmill_N = DictGer.tretmuehle_N ;
|
|
treasure_N = DictGer.schatz_N ;
|
|
treat_V = DictGer.bewirten_V ;
|
|
treat_V2 = P.dirV2 (DictGer.bewirten_V) ;
|
|
treatise_N = DictGer.abhandlung_N ;
|
|
treatment_N = DictGer.behandlung_N ;
|
|
treaty_N = DictGer.buendnis_N ;
|
|
tree_N = LexiconGer.tree_N ;
|
|
trefoil_N = DictGer.dreipass_N ;
|
|
trellis_N = DictGer.spalier_N ;
|
|
tremble_V = DictGer.zittern_V ;
|
|
tremendous_A = DictGer.ausserordentlich_A ;
|
|
tremulous_A = DictGer.furchtsam_A ;
|
|
trench_N = DictGer.graben_N ;
|
|
trend_N = DictGer.trend_N ;
|
|
trendy_A = DictGer.trendig_A ;
|
|
trespass_N = DictGer.hausfriedensbruch_N ;
|
|
triad_N = DictGer.dreiklang_N ;
|
|
trial_N = DictGer.belaestigung_N ;
|
|
triangle_N = DictGer.dreieck_N ;
|
|
triangular_A = DictGer.dreieckig_A ;
|
|
tribe_N = DictGer.sippe_N ;
|
|
tribulation_N = DictGer.truebsal_N ;
|
|
tributary_N = DictGer.nebenfluss_N ;
|
|
tribute_N = DictGer.tribut_N ;
|
|
trickle_N = DictGer.rinnsal_N ;
|
|
tricky_A = DictGer.gerissen_A ;
|
|
tricycle_N = DictGer.dreirad_N ;
|
|
trident_N = DictGer.dreizack_N ;
|
|
trifle_N = DictGer.kleinigkeit_N ;
|
|
trifling_A = DictGer.unbedeutend_A ;
|
|
trigger_N = DictGer.abzug_N ;
|
|
trill_N = DictGer.vibrant_N ;
|
|
trilogy_N = DictGer.trilogie_N ;
|
|
trim_V = DictGer.schmuecken_4_V ;
|
|
trim_V2 = P.dirV2 (DictGer.schmuecken_4_V) ;
|
|
trio_N = DictGer.trio_N ;
|
|
trip_N = DictGer.reise_N ;
|
|
tripe_N = DictGer.eingeweide_N ;
|
|
triplet_N = DictGer.drilling_N ;
|
|
tripod_N = DictGer.stativ_N ;
|
|
trite_A = DictGer.banal_A ;
|
|
triumph_N = DictGer.triumph_N ;
|
|
trochee_N = DictGer.trochaeus_N ;
|
|
troika_N = DictGer.troika_N ;
|
|
troll_N = DictGer.troll_N ;
|
|
trollop_N = DictGer.dirne_N ;
|
|
trombone_N = DictGer.posaune_N ;
|
|
trope_N = DictGer.tropus_N ;
|
|
trophy_N = DictGer.trophaee_N ;
|
|
tropical_A = DictGer.tropisch_A ;
|
|
trouble_N = DictGer.stoerung_N ;
|
|
troublemaker_N = DictGer.querulant_N ;
|
|
troublesome_A = DictGer.laestig_A ;
|
|
trough_N = DictGer.trog_N ;
|
|
troupe_N = DictGer.truppe_N ;
|
|
trout_N = DictGer.forelle_N ;
|
|
truce_N = DictGer.waffenstillstand_N ;
|
|
true_A = DictGer.echt_A ;
|
|
truism_N = DictGer.binsenwahrheit_N ;
|
|
trump_N = DictGer.trumpf_N ;
|
|
trumpet_N = DictGer.trompete_N ;
|
|
trumpeter_N = DictGer.trompeter_N ;
|
|
trunk_N = DictGer.koffer_N ;
|
|
trust_N = DictGer.hoffnung_N ;
|
|
trustworthy_A = DictGer.glaubwuerdig_A ;
|
|
truth_N = DictGer.wahrheit_N ;
|
|
truthful_A = DictGer.wahrheitsgemaess_A ;
|
|
try_V = DictGer.kosten_V ;
|
|
try_V2 = P.dirV2 (DictGer.kosten_V) ;
|
|
tryst_N = DictGer.stelldichein_N ;
|
|
tsar_N = DictGer.zar_N ;
|
|
tub_N = DictGer.bottich_N ;
|
|
tuba_N = DictGer.tuba_N ;
|
|
tube_N = DictGer.rohr_N ;
|
|
tuber_N = DictGer.knolle_N ;
|
|
tuberculosis_N = DictGer.tuberkulose_N ;
|
|
tuesday_N = DictGer.dienstag_N ;
|
|
tug_N = DictGer.ruck_N ;
|
|
tugboat_N = DictGer.schlepper_N ;
|
|
tulip_N = DictGer.tulpe_N ;
|
|
tumble_N = DictGer.sturz_N ;
|
|
tumbler_N = DictGer.trinkglas_N ;
|
|
tummy_N = DictGer.bauch_N ;
|
|
tuna_N = DictGer.thunfisch_N ;
|
|
tundra_N = DictGer.tundra_N ;
|
|
tune_N = DictGer.melodie_N ;
|
|
tunic_N = DictGer.tunika_N ;
|
|
turban_N = DictGer.turban_N ;
|
|
turbine_N = DictGer.turbine_N ;
|
|
turbot_N = DictGer.steinbutt_N ;
|
|
turbulence_N = DictGer.turbulenz_N ;
|
|
turd_N = DictGer.haufen_N ;
|
|
tureen_N = DictGer.terrine_N ;
|
|
turf_N = DictGer.rasen_N ;
|
|
turkey_N = DictGer.pute_N ;
|
|
turmoil_N = DictGer.aufruhr_N ;
|
|
turn_V = LexiconGer.turn_V ;
|
|
turn_V2 = P.dirV2 (DictGer.biegen_0_V) ;
|
|
turncoat_N = DictGer.ueberlaeufer_N ;
|
|
turnover_N = DictGer.fluktuation_N ;
|
|
turtle_N = DictGer.schildkroete_N ;
|
|
tutu_N = DictGer.tutu_N ;
|
|
tuxedo_N = DictGer.abendanzug_N ;
|
|
twig_N = DictGer.zweig_N ;
|
|
twilight_N = DictGer.daemmerung_N ;
|
|
twin_N = DictGer.zwilling_N ;
|
|
twist_N = DictGer.biegung_N ;
|
|
twofold_A = DictGer.zweifach_A ;
|
|
tycoon_N = DictGer.tycoon_N ;
|
|
type_N = DictGer.art_N ;
|
|
typewriter_N = DictGer.schreibmaschine_N ;
|
|
typhoon_N = DictGer.taifun_N ;
|
|
typical_A = DictGer.typisch_A ;
|
|
typography_N = DictGer.typographie_N ;
|
|
tyranny_N = DictGer.tyrannei_N ;
|
|
tyrant_N = DictGer.tyrann_N ;
|
|
tyre_N = DictGer.reifen_N ;
|
|
udder_N = DictGer.euter_N ;
|
|
ufo_N = DictGer.ufo_N ;
|
|
ugly_A = LexiconGer.ugly_A ;
|
|
ulcer_N = DictGer.geschwuer_N ;
|
|
ulcerous_A = DictGer.eitrig_A ;
|
|
ultimate_A = DictGer.ultimativ_A ;
|
|
ultramontane_A = DictGer.ultramontan_A ;
|
|
ultraviolet_A = DictGer.ultraviolett_A ;
|
|
umbrage_N = DictGer.anstoss_N ;
|
|
umbrella_N = DictGer.dach_N ;
|
|
umlaut_N = DictGer.umlaut_N ;
|
|
unable_A = DictGer.unfaehig_A ;
|
|
unaltered_A = DictGer.unveraendert_A ;
|
|
unambiguous_A = DictGer.eindeutig_A ;
|
|
unbearable_A = DictGer.unertraeglich_A ;
|
|
unbelievable_A = DictGer.unglaublich_A ;
|
|
unbridled_A = DictGer.zuegellos_A ;
|
|
uncanny_A = DictGer.unheimlich_A ;
|
|
uncertain_A = LexiconGer.uncertain_A ;
|
|
uncertainty_N = DictGer.unsicherheit__N ;
|
|
uncle_N = DictGer.oheim_N ;
|
|
uncomfortable_A = DictGer.unbehaglich_A ;
|
|
uncompromising_A = DictGer.kompromisslos_A ;
|
|
unconscious_A = DictGer.bewusstlos_A ;
|
|
unconventional_A = DictGer.unkonventionell_A ;
|
|
uncork_V2 = P.dirV2 (DictGer.entkorken_V) ;
|
|
underdog_N = DictGer.aussenseiter_N ;
|
|
underestimate_V2 = P.dirV2 (DictGer.unterschaetzen_V) ;
|
|
undermine_V2 = P.dirV2 (DictGer.unterminieren_V) ;
|
|
underpin_V2 = P.dirV2 (DictGer.stuetzen_2_V) ;
|
|
understand_V = DictGer.begreifen_V ;
|
|
understand_V2 = P.dirV2 (DictGer.begreifen_V) ;
|
|
understandable_A = DictGer.verstaendlich_A ;
|
|
understanding_N = DictGer.einigung_N ;
|
|
understate_V2 = P.dirV2 (DictGer.untertreiben_V) ;
|
|
underworld_N = DictGer.unterwelt_N ;
|
|
underwrite_V = DictGer.unterschreiben_V ;
|
|
undesirable_A = DictGer.unerwuenscht_A ;
|
|
undetermined_A = DictGer.unbestimmt_A ;
|
|
undisclosed_A = DictGer.geheim_A ;
|
|
undue_A = DictGer.unangemessen_A ;
|
|
undulate_V = DictGer.wallen_V ;
|
|
unemployed_A = DictGer.arbeitslos_A ;
|
|
unequivocal_A = DictGer.eindeutig_A ;
|
|
unethical_A = DictGer.unethisch_A ;
|
|
unexpected_A = DictGer.unerwartet_A ;
|
|
unfaithful_A = DictGer.unglaeubig_A ;
|
|
unflappable_A = DictGer.unerschuetterlich_A ;
|
|
unfold_V = DictGer.entfalten_V ;
|
|
unfold_V2 = P.dirV2 (DictGer.entfalten_V) ;
|
|
unforgettable_A = DictGer.unvergesslich_A ;
|
|
unfortunate_A = DictGer.ungluecklich_A ;
|
|
unfounded_A = DictGer.unbegruendet_A ;
|
|
ungainly_A = DictGer.plump_A ;
|
|
unguent_N = DictGer.salbe_N ;
|
|
unhappy_A = DictGer.ungluecklich_A ;
|
|
unicorn_N = DictGer.einhorn_N ;
|
|
unification_N = DictGer.vereinigung_N ;
|
|
uniform_A = DictGer.einheitlich_A ;
|
|
unify_V2 = P.dirV2 (DictGer.vereinigen_V) ;
|
|
unilateral_A = DictGer.einseitig_A ;
|
|
unimaginable_A = DictGer.unvorstellbar_A ;
|
|
unimportant_A = DictGer.unwichtig_A ;
|
|
uninhabitable_A = DictGer.unbewohnbar_A ;
|
|
uninhabited_A = DictGer.unbewohnt_A ;
|
|
unintentional_A = DictGer.unbeabsichtigt_A ;
|
|
uninteresting_A = DictGer.uninteressant_A ;
|
|
union_N = DictGer.union_N ;
|
|
unique_A = DictGer.einzigartig_A ;
|
|
unit_N = DictGer.einheit_N ;
|
|
unity_N = DictGer.einheit_N ;
|
|
universe_N = DictGer.universum_N ;
|
|
university_N = LexiconGer.university_N ;
|
|
unjust_A = DictGer.ungerecht_A ;
|
|
unkempt_A = DictGer.struppig_A ;
|
|
unknown_A = DictGer.unbekannt_A ;
|
|
unlawful_A = DictGer.gesetzeswidrig_A ;
|
|
unlikely_A = DictGer.unwahrscheinlich_A ;
|
|
unmanned_A = DictGer.unbemannt_A ;
|
|
unmarried_A = DictGer.ledig_A ;
|
|
unnecessary_A = DictGer.unnoetig_A ;
|
|
unobtrusive_A = DictGer.bescheiden_A ;
|
|
unpleasant_A = DictGer.unangenehm_A ;
|
|
unpopular_A = DictGer.unpopulaer_A ;
|
|
unprecedented_A = DictGer.beispiellos_A ;
|
|
unprotected_A = DictGer.ungeschuetzt_A ;
|
|
unrealistic_A = DictGer.unrealistisch_A ;
|
|
unreasonable_A = DictGer.unvernuenftig_A ;
|
|
unsaturated_A = DictGer.ungesaettigt_A ;
|
|
unscientific_A = DictGer.unwissenschaftlich_A ;
|
|
unscrupulous_A = DictGer.skrupellos_A ;
|
|
unshaven_A = DictGer.unrasiert_A ;
|
|
unsportsmanlike_A = DictGer.unsportlich_A ;
|
|
unstressed_A = DictGer.unbetont_A ;
|
|
unthinkable_A = DictGer.unvorstellbar_A ;
|
|
untidy_A = DictGer.unordentlich_A ;
|
|
untruth_N = DictGer.unwahrheit_N ;
|
|
unusual_A = DictGer.ungewoehnlich_A ;
|
|
unveil_V = DictGer.enthuellen_V ;
|
|
unveil_V2 = P.dirV2 (DictGer.enthuellen_V) ;
|
|
unwanted_A = DictGer.unerwuenscht_A ;
|
|
unwary_A = DictGer.unbedarft_A ;
|
|
upgrade_N = DictGer.upgrade_N ;
|
|
upheaval_N = DictGer.aufruhr_N ;
|
|
upkeep_N = DictGer.wartung_N ;
|
|
uprising_N = DictGer.aufstand_N ;
|
|
uproar_N = DictGer.aufruhr_N ;
|
|
upstart_N = DictGer.emporkoemmling_N ;
|
|
urbanization_N = DictGer.urbanisierung_N ;
|
|
urchin_N = DictGer.igel_N ;
|
|
urge_N = DictGer.drang_N ;
|
|
urgent_A = DictGer.dringend_A ;
|
|
urinal_N = DictGer.urinal_N ;
|
|
urinate_V = DictGer.urinieren_V ;
|
|
urine_N = DictGer.harn_N ;
|
|
urn_N = DictGer.urne_N ;
|
|
usable_A = DictGer.nutzbar_A ;
|
|
usage_N = DictGer.gebrauch_N ;
|
|
use_N = DictGer.anwendung_N ;
|
|
useful_A = DictGer.nuetzlich_A ;
|
|
useless_A = DictGer.nutzlos_A ;
|
|
user_N = DictGer.benutzer_N ;
|
|
usher_N = DictGer.gerichtsdiener_N ;
|
|
usual_A = DictGer.gewoehnlich_A ;
|
|
usurer_N = DictGer.wucher_N ;
|
|
usurp_V2 = P.dirV2 (DictGer.usurpieren_V) ;
|
|
usurper_N = DictGer.usurpator_N ;
|
|
usury_N = DictGer.wucher_N ;
|
|
utopia_N = DictGer.utopie_N ;
|
|
utopian_A = DictGer.utopisch_A ;
|
|
utter_A = DictGer.voellig_A ;
|
|
utterance_N = DictGer.aussprache_N ;
|
|
uvula_N = DictGer.uvula_N ;
|
|
vacancy_N = DictGer.vakanz_N ;
|
|
vacant_A = DictGer.vakant_A ;
|
|
vacation_N = DictGer.urlaub_N ;
|
|
vaccinate_V2 = P.dirV2 (DictGer.impfen_1_V) ;
|
|
vaccination_N = DictGer.impfung_N ;
|
|
vaccine_N = DictGer.impfstoff_N ;
|
|
vacuum_N = DictGer.staubsauger_N ;
|
|
vagina_N = DictGer.scheide_N ;
|
|
vaginal_A = DictGer.vaginal_A ;
|
|
vague_A = DictGer.nebelhaft_A ;
|
|
vain_A = DictGer.eitel_A ;
|
|
vale_N = DictGer.tal_N ;
|
|
valerian_N = DictGer.baldrian_N ;
|
|
valiant_A = DictGer.beherzt_A ;
|
|
valid_A = DictGer.gueltig_A ;
|
|
validate_V2 = P.dirV2 (DictGer.validieren_V) ;
|
|
valley_N = DictGer.senke_N ;
|
|
valuable_A = DictGer.wertvoll_A ;
|
|
value_N = DictGer.wert_N ;
|
|
valve_N = DictGer.klappe_N ;
|
|
vampire_N = DictGer.vampir_N ;
|
|
van_N = DictGer.lieferwagen_N ;
|
|
vanguard_N = DictGer.avantgarde_N ;
|
|
vanish_V = DictGer.verschwinden_V ;
|
|
vanity_N = DictGer.eitelkeit_N ;
|
|
vapour_N = DictGer.dampf_N ;
|
|
variable_A = DictGer.variabel_A ;
|
|
variation_N = DictGer.variante_N ;
|
|
variegated_A = DictGer.bunt_A ;
|
|
variety_N = DictGer.sorte_N ;
|
|
varnish_N = DictGer.firnis_N ;
|
|
vascular_A = DictGer.vaskulaer_A ;
|
|
vase_N = DictGer.vase_N ;
|
|
vaseline_N = DictGer.vaseline_N ;
|
|
vassal_N = DictGer.vasall_N ;
|
|
vast_A = DictGer.betraechtlich_A ;
|
|
vat_N = DictGer.bottich_N ;
|
|
vault_N = DictGer.gewoelbe_N ;
|
|
veal_N = DictGer.kalbfleisch_N ;
|
|
vector_N = DictGer.vektor_N ;
|
|
vegetable_N = DictGer.gemuese_N ;
|
|
vegetarian_N = DictGer.pflanzenfresser_N ;
|
|
vehement_A = DictGer.heftig_A ;
|
|
vehicle_N = DictGer.fahrzeug_N ;
|
|
vein_N = DictGer.ader_N ;
|
|
velocipede_N = DictGer.veloziped_N ;
|
|
velour_N = DictGer.velours_N ;
|
|
velvet_N = DictGer.samt_N ;
|
|
vendor_N = DictGer.verkaeufer_N ;
|
|
veneer_N = DictGer.fassade_N ;
|
|
vengeance_N = DictGer.vergeltung_N ;
|
|
venom_N = DictGer.gift_N ;
|
|
vent_N = DictGer.oeffnung_N ;
|
|
ventilator_N = DictGer.luefter_N ;
|
|
ventriloquist_N = DictGer.bauchredner_N ;
|
|
venue_N = DictGer.austragungsort_N ;
|
|
verandah_N = DictGer.veranda_N ;
|
|
verb_N = DictGer.verb_N ;
|
|
verbose_A = DictGer.wortreich_A ;
|
|
verbosity_N = DictGer.verbositaet_N ;
|
|
verdant_A = DictGer.frisch_A ;
|
|
verdict_N = DictGer.urteil_N ;
|
|
verge_N = DictGer.rand_N ;
|
|
vermin_N = DictGer.ungeziefer_N ;
|
|
vermouth_N = DictGer.wermut_N ;
|
|
vernacular_N = DictGer.amtssprache_N ;
|
|
vernal_A = DictGer.fruehlingshaft_A ;
|
|
versatile_A = DictGer.beweglich_A ;
|
|
versed_A = DictGer.versiert_A ;
|
|
versify_V = DictGer.versifizieren_V ;
|
|
versify_V2 = P.dirV2 (DictGer.versifizieren_V) ;
|
|
version_N = DictGer.version_N ;
|
|
vertex_N = DictGer.ecke_N ;
|
|
verve_N = DictGer.begeisterung_N ;
|
|
vessel_N = DictGer.behaelter_N ;
|
|
vest_N = DictGer.unterhemd_N ;
|
|
vestibule_N = DictGer.vestibuel_N ;
|
|
vestige_N = DictGer.spur_N ;
|
|
vestigial_A = DictGer.rudimentaer_A ;
|
|
vet_N = DictGer.tierarzt__N ;
|
|
vetch_N = DictGer.wicke_N ;
|
|
veto_N = DictGer.veto_N ;
|
|
vex_V2 = P.dirV2 (DictGer.aergern_V) ;
|
|
viable_A = DictGer.machbar_A ;
|
|
vibrant_A = DictGer.kraeftig_A ;
|
|
vibrate_V = DictGer.vibrieren_V ;
|
|
vibrate_V2 = P.dirV2 (DictGer.vibrieren_V) ;
|
|
vibrator_N = DictGer.vibrator_N ;
|
|
vice_N = DictGer.schraubstock_N ;
|
|
vicinity_N = DictGer.nachbarschaft_N ;
|
|
vicissitude_N = DictGer.wandel_N ;
|
|
victim_N = DictGer.opfer_N ;
|
|
victor_N = DictGer.sieger_N ;
|
|
victory_N = DictGer.sieg_N ;
|
|
video_N = DictGer.video_N ;
|
|
vietnamese_A = DictGer.vietnamesisch_A ;
|
|
view_N = DictGer.anblick_N ;
|
|
viewer_N = DictGer.zuschauer_N ;
|
|
vigil_N = DictGer.wache_N ;
|
|
vignette_N = DictGer.vignette_N ;
|
|
vilify_V2 = P.dirV2 (DictGer.diffamieren_V) ;
|
|
village_N = LexiconGer.village_N ;
|
|
villager_N = DictGer.dorfbewohner_N ;
|
|
villain_N = DictGer.gauner_N ;
|
|
vindicate_V2 = P.dirV2 (DictGer.rechtfertigen_V) ;
|
|
vindication_N = DictGer.rechtfertigung_N ;
|
|
vine_N = DictGer.rebe_N ;
|
|
vinegar_N = DictGer.essig_N ;
|
|
vineyard_N = DictGer.weinberg_N ;
|
|
vintage_N = DictGer.jahrgang_N ;
|
|
vintner_N = DictGer.weinhaendler_N ;
|
|
vinyl_N = DictGer.schallplatte_N ;
|
|
viola_N = DictGer.bratsche_N ;
|
|
violation_N = DictGer.verletzung_N ;
|
|
violence_N = DictGer.gewalt_N ;
|
|
violent_A = DictGer.brutal_A ;
|
|
violet_N = DictGer.veilchen_N ;
|
|
violin_N = DictGer.geige_N ;
|
|
violinist_N = DictGer.violinist_N ;
|
|
viper_N = DictGer.kreuzotter_N ;
|
|
virgin_N = DictGer.jungfrau_N ;
|
|
virtual_A = DictGer.eigentlich_A ;
|
|
virtue_N = DictGer.tugend_N ;
|
|
virtuoso_N = DictGer.virtuose_N ;
|
|
visceral_A = DictGer.intuitiv_A ;
|
|
viscosity_N = DictGer.viskositaet_N ;
|
|
viscous_A = DictGer.viskos_A ;
|
|
visibility_N = DictGer.sicht_N ;
|
|
visible_A = DictGer.sichtbar_A ;
|
|
vision_N = DictGer.sicht_N ;
|
|
visionary_A = DictGer.ideal_A ;
|
|
visit_V = DictGer.besuchen_V ;
|
|
visit_V2 = P.dirV2 (DictGer.besuchen_V) ;
|
|
visitor_N = DictGer.besucher_N ;
|
|
visor_N = DictGer.visier_N ;
|
|
vista_N = DictGer.aussicht_N ;
|
|
visual_A = DictGer.visuell_A ;
|
|
vitamin_N = DictGer.vitamin_N ;
|
|
vitiate_V2 = P.dirV2 (DictGer.beschaedigen_V) ;
|
|
vitreous_A = DictGer.glasig_A ;
|
|
vituperate_V2 = P.dirV2 (DictGer.schelten_V) ;
|
|
vivacious_A = DictGer.langlebig_A ;
|
|
vivisection_N = DictGer.vivisektion_N ;
|
|
vixen_N = DictGer.drachen_N ;
|
|
vocabulary_N = DictGer.vokabular_N ;
|
|
vocation_N = DictGer.berufung_N ;
|
|
vodka_N = DictGer.wodka_N ;
|
|
vogue_N = DictGer.mode_N ;
|
|
voice_N = DictGer.diathese_N ;
|
|
voiceless_A = DictGer.stimmlos_A ;
|
|
void_A = DictGer.nichtig_A ;
|
|
volatile_A = DictGer.volatil_A ;
|
|
volatility_N = DictGer.volatilitaet_N ;
|
|
volcanic_A = DictGer.vulkanisch_A ;
|
|
volcano_N = DictGer.vulkan_N ;
|
|
volleyball_N = DictGer.volleyball_N ;
|
|
volt_N = DictGer.volt_N ;
|
|
voltage_N = DictGer.spannung_N ;
|
|
volume_N = DictGer.jahrgang_N ;
|
|
voluminous_A = DictGer.voluminoes_A ;
|
|
voluntary_A = DictGer.freiwillig_A ;
|
|
vomit_V = LexiconGer.vomit_V ;
|
|
vortex_N = DictGer.wirbel_N ;
|
|
vote_N = DictGer.abstimmung_N ;
|
|
voucher_N = DictGer.beleg_N ;
|
|
vouchsafe_V2 = P.dirV2 (DictGer.gewaehren_V) ;
|
|
vow_N = DictGer.eid_N ;
|
|
vowel_N = DictGer.selbstlaut_N ;
|
|
voyage_N = DictGer.reise_N ;
|
|
voyeur_N = DictGer.spanner_N ;
|
|
vulcanize_V2 = P.dirV2 (DictGer.vulkanisieren_V) ;
|
|
vulgar_A = DictGer.allgemein_A ;
|
|
vulnerability_N = DictGer.verwundbarkeit_N ;
|
|
vulture_N = DictGer.geier_N ;
|
|
wad_N = DictGer.wichse_N ;
|
|
wade_V = DictGer.waten_V ;
|
|
wade_V2 = P.dirV2 (DictGer.waten_V) ;
|
|
wader_N = DictGer.watvogel_N ;
|
|
wafer_N = DictGer.oblate_N ;
|
|
waffle_N = DictGer.waffel_N ;
|
|
wag_V = DictGer.schwaenzen_V ;
|
|
wag_V2 = P.dirV2 (DictGer.schwaenzen_V) ;
|
|
wage_N = DictGer.lohn_N ;
|
|
wager_N = DictGer.wette_N ;
|
|
waggle_V = DictGer.wackeln_V ;
|
|
waggle_V2 = P.dirV2 (DictGer.wackeln_V) ;
|
|
waist_N = DictGer.rumpf_N ;
|
|
waistcoat_N = DictGer.weste_N ;
|
|
waistline_N = DictGer.taille_N ;
|
|
wait_V = DictGer.bedienen_V ;
|
|
wait_V2 = LexiconGer.wait_V2 ;
|
|
waiter_N = DictGer.kellner_N ;
|
|
waitress_N = DictGer.kellnerin_N ;
|
|
waive_V2 = P.dirV2 (DictGer.verlassen_V) ;
|
|
wake_V = DictGer.wecken_6_V ;
|
|
wake_V2 = P.dirV2 (DictGer.wecken_6_V) ;
|
|
walk_V = LexiconGer.walk_V ;
|
|
walk_V2 = P.dirV2 (DictGer.gehen_0_V) ;
|
|
wallet_N = DictGer.brieftasche_N ;
|
|
wallflower_N = DictGer.mauerbluemchen_N ;
|
|
wallpaper_N = DictGer.tapete_N ;
|
|
walnut_N = DictGer.walnuss_N ;
|
|
walrus_N = DictGer.walross_N ;
|
|
waltz_N = DictGer.walzer_N ;
|
|
wan_A = DictGer.fahl_A ;
|
|
wand_N = DictGer.stab_N ;
|
|
wank_V = DictGer.onanieren_V ;
|
|
want_V = DictGer.wollen_7_V ;
|
|
want_V2 = P.dirV2 (DictGer.wollen_7_V) ;
|
|
war_N = LexiconGer.war_N ;
|
|
ward_N = DictGer.station_N ;
|
|
warden_N = DictGer.aufseher_N ;
|
|
wardrobe_N = DictGer.garderobe_N ;
|
|
warm_A = LexiconGer.warm_A ;
|
|
warmonger_N = DictGer.bellizist_N ;
|
|
warn_V = DictGer.warnen_V ;
|
|
warn_V2 = P.dirV2 (DictGer.warnen_V) ;
|
|
warranty_N = DictGer.garantie_N ;
|
|
warrior_N = DictGer.krieger_N ;
|
|
warship_N = DictGer.kriegsschiff_N ;
|
|
wart_N = DictGer.warze_N ;
|
|
warthog_N = DictGer.warzenschwein_N ;
|
|
wary_A = DictGer.achtsam_A ;
|
|
wash_V = DictGer.spuelen_1_V ;
|
|
wash_V2 = LexiconGer.wash_V2 ;
|
|
washcloth_N = DictGer.waschlappen_N ;
|
|
washer_N = DictGer.scheibe_N ;
|
|
wasp_N = DictGer.wespe_N ;
|
|
waste_N = DictGer.einoede_N ;
|
|
wasteful_A = DictGer.verschwenderisch_A ;
|
|
wasteland_N = DictGer.wueste_N ;
|
|
watch_N = DictGer.armbanduhr_N ;
|
|
watch_V2 = LexiconGer.watch_V2 ;
|
|
watchmaker_N = DictGer.uhrmacher_N ;
|
|
watchman_N = DictGer.waechter_N ;
|
|
watchtower_N = DictGer.wachturm_N ;
|
|
water_N = LexiconGer.water_N ;
|
|
watercourse_N = DictGer.wasserlauf_N ;
|
|
watercress_N = DictGer.brunnenkresse_N ;
|
|
waterfall_N = DictGer.kaskade_N ;
|
|
watermark_N = DictGer.wasserzeichen_N ;
|
|
watermelon_N = DictGer.wassermelone_N ;
|
|
watermill_N = DictGer.wassermuehle_N ;
|
|
waterproof_A = DictGer.wasserdicht_A ;
|
|
watershed_N = DictGer.wasserscheide_N ;
|
|
watertight_A = DictGer.wasserdicht_A ;
|
|
watt_N = DictGer.watt_N ;
|
|
wave_V = DictGer.winken_1_V ;
|
|
wave_V2 = P.dirV2 (DictGer.winken_1_V) ;
|
|
wavelength_N = DictGer.wellenlaenge_N ;
|
|
wax_N = DictGer.wachs_N ;
|
|
way_N = DictGer.art_N ;
|
|
waybill_N = DictGer.frachtbrief_N ;
|
|
wayfarer_N = DictGer.wandersmann_N ;
|
|
wayward_A = DictGer.eigenwillig_A ;
|
|
weak_A = DictGer.schwach_A ;
|
|
weakness_N = DictGer.schwaeche_N ;
|
|
wealth_N = DictGer.fuelle_N ;
|
|
wealthy_A = DictGer.reich_A ;
|
|
weapon_N = DictGer.waffe_N ;
|
|
wear_V = DictGer.tragen_7_V ;
|
|
wear_V2 = P.dirV2 (DictGer.tragen_7_V) ;
|
|
wearable_A = DictGer.tragbar_A ;
|
|
weary_A = DictGer.muede_A ;
|
|
weasel_N = DictGer.wiesel_N ;
|
|
weather_N = DictGer.wetter_N ;
|
|
weatherman_N = DictGer.wetterfrosch_N ;
|
|
weave_V = DictGer.weben_V ;
|
|
weave_V2 = P.dirV2 (DictGer.weben_V) ;
|
|
weaver_N = DictGer.weber_N ;
|
|
web_N = DictGer.netz_N ;
|
|
wed_V = DictGer.heiraten_V ;
|
|
wed_V2 = P.dirV2 (DictGer.heiraten_V) ;
|
|
wedge_N = DictGer.keil_N ;
|
|
wednesday_N = DictGer.mittwoch_N ;
|
|
wee_A = DictGer.winzig_A ;
|
|
weed_N = DictGer.glimmstaengel_N ;
|
|
week_N = DictGer.woche_N ;
|
|
weekday_N = DictGer.wochentag_N ;
|
|
weekend_N = DictGer.wochenende_N ;
|
|
weep_V = DictGer.weinen_V ;
|
|
weep_V2 = P.dirV2 (DictGer.weinen_V) ;
|
|
weigh_V = DictGer.wiegen_2_V ;
|
|
weigh_V2 = P.dirV2 (DictGer.wiegen_2_V) ;
|
|
weight_N = DictGer.gewicht_N ;
|
|
weir_N = DictGer.wehr_N ;
|
|
welcome_V2 = P.dirV2 (DictGer.begruessen_V) ;
|
|
welder_N = DictGer.schweisser_N ;
|
|
wench_N = DictGer.magd_N ;
|
|
wet_A = LexiconGer.wet_A ;
|
|
wether_N = DictGer.hammel_N ;
|
|
whack_N = DictGer.schlag_N ;
|
|
whale_N = DictGer.wal_N ;
|
|
wharf_N = DictGer.kai_N ;
|
|
whatever_A = DictGer.egal_A ;
|
|
wheat_N = DictGer.weizen_N ;
|
|
wheel_N = DictGer.lenkrad_N ;
|
|
wheelbarrow_N = DictGer.schubkarre_N ;
|
|
wheelchair_N = DictGer.rollstuhl_N ;
|
|
whelp_N = DictGer.welpe_N ;
|
|
whetstone_N = DictGer.schleifstein_N ;
|
|
whey_N = DictGer.molke_N ;
|
|
whiff_N = DictGer.hauch_N ;
|
|
while_N = DictGer.zeitspanne_N ;
|
|
whim_N = DictGer.grille_N ;
|
|
whip_N = DictGer.peitsche_N ;
|
|
whirlwind_N = DictGer.wirbelsturm_N ;
|
|
whiskey_N = DictGer.whisky_N ;
|
|
whistle_N = DictGer.pfeife_N ;
|
|
white_A = LexiconGer.white_A ;
|
|
whiten_V = DictGer.weissen_V ;
|
|
whiten_V2 = P.dirV2 (DictGer.weissen_V) ;
|
|
whiting_N = DictGer.merlan_N ;
|
|
whole_A = DictGer.ganz_A ;
|
|
whore_N = DictGer.dirne_N ;
|
|
wick_N = DictGer.docht_N ;
|
|
wicked_A = DictGer.boese_A ;
|
|
wide_A = LexiconGer.wide_A ;
|
|
widen_V = DictGer.erweitern_V ;
|
|
widen_V2 = P.dirV2 (DictGer.erweitern_V) ;
|
|
widow_N = DictGer.hurenkind_N ;
|
|
widowed_A = DictGer.verwitwet_A ;
|
|
widower_N = DictGer.witwer_N ;
|
|
width_N = DictGer.breite_N ;
|
|
wife_N = LexiconGer.wife_N ;
|
|
wig_N = DictGer.peruecke_N ;
|
|
wiggle_V = DictGer.wackeln_V ;
|
|
wiggle_V2 = P.dirV2 (DictGer.wackeln_V) ;
|
|
wild_A = DictGer.wild_A ;
|
|
wildfire_N = DictGer.lauffeuer_N ;
|
|
will_N = DictGer.wille_N ;
|
|
willingness_N = DictGer.bereitschaft_N ;
|
|
willow_N = DictGer.weide_N ;
|
|
wilt_V = DictGer.welken_V ;
|
|
wilt_V2 = P.dirV2 (DictGer.welken_V) ;
|
|
wily_A = DictGer.schlau_A ;
|
|
win_V = DictGer.erobern_V ;
|
|
win_V2 = LexiconGer.win_V2 ;
|
|
winch_N = DictGer.winde_N ;
|
|
wind_N = LexiconGer.wind_N ;
|
|
windmill_N = DictGer.windmuehle_N ;
|
|
window_N = LexiconGer.window_N ;
|
|
windowpane_N = DictGer.fensterscheibe_N ;
|
|
windpipe_N = DictGer.luftroehre_N ;
|
|
windshield_N = DictGer.windschutzscheibe__N ;
|
|
wine_N = LexiconGer.wine_N ;
|
|
wing_N = LexiconGer.wing_N ;
|
|
wink_V = DictGer.zwinkern_V ;
|
|
wink_V2 = P.dirV2 (DictGer.zwinkern_V) ;
|
|
winner_N = DictGer.gewinner_N ;
|
|
winnow_V2 = P.dirV2 (DictGer.worfeln_V) ;
|
|
winter_N = DictGer.winter_N ;
|
|
wintry_A = DictGer.winterlich_A ;
|
|
wipe_V = DictGer.loeschen_5_V ;
|
|
wipe_V2 = LexiconGer.wipe_V2 ;
|
|
wire_N = DictGer.draht_N ;
|
|
wireless_A = DictGer.drahtlos_A ;
|
|
wisdom_N = DictGer.weisheit_N ;
|
|
wise_A = DictGer.klug_A ;
|
|
wiseacre_N = DictGer.klugscheisser_N ;
|
|
wish_N = DictGer.wunsch_N ;
|
|
wisp_N = DictGer.wisch_N ;
|
|
wispy_A = DictGer.duenn_A ;
|
|
wit_N = DictGer.witz_N ;
|
|
witch_N = DictGer.hexe_N ;
|
|
withstand_V2 = P.dirV2 (DictGer.widerstehen_V) ;
|
|
witty_A = DictGer.geistreich_A ;
|
|
wizard_N = DictGer.assistent_N ;
|
|
wizardry_N = DictGer.zauberei_N ;
|
|
woe_N = DictGer.weh_N ;
|
|
wolf_N = DictGer.wolf_N ;
|
|
woman_N = LexiconGer.woman_N ;
|
|
womanizer_N = DictGer.schuerzenjaeger_N ;
|
|
womanly_A = DictGer.weiblich_A ;
|
|
womb_N = DictGer.gebaermutter_N ;
|
|
wombat_N = DictGer.wombat_N ;
|
|
wonder_N = DictGer.mirakel_N ;
|
|
wonderful_A = DictGer.wunderbar_A ;
|
|
wondrous_A = DictGer.wundersam_A ;
|
|
wont_N = DictGer.gewohnheit_N ;
|
|
wood_N = LexiconGer.wood_N ;
|
|
wooden_A = DictGer.hoelzern_A ;
|
|
woodland_N = DictGer.forst_N ;
|
|
woodpecker_N = DictGer.specht_N ;
|
|
wool_N = DictGer.wolle_N ;
|
|
word_N = DictGer.ehrenwort_N ;
|
|
wording_N = DictGer.formulierung_N ;
|
|
wordy_A = DictGer.wortreich_A ;
|
|
work_N = DictGer.arbeit_N ;
|
|
workbench_N = DictGer.werkbank_N ;
|
|
worker_N = DictGer.arbeiter_N ;
|
|
workroom_N = DictGer.arbeitszimmer_N ;
|
|
workshop_N = DictGer.werkstatt_N ;
|
|
world_N = DictGer.erde_N ;
|
|
worldwide_A = DictGer.weltweit_A ;
|
|
worm_N = LexiconGer.worm_N ;
|
|
wormwood_N = DictGer.wermut_N ;
|
|
worried_A = DictGer.besorgt_A ;
|
|
worry_V = DictGer.besorgen_V ;
|
|
worry_V2 = P.dirV2 (DictGer.besorgen_V) ;
|
|
worship_N = DictGer.anbetung_N ;
|
|
worthless_A = DictGer.wertlos_A ;
|
|
worthwhile_A = DictGer.wertvoll_A ;
|
|
wound_N = DictGer.verletzung_N ;
|
|
wrangle_V = DictGer.rangeln_V ;
|
|
wreak_V2 = P.dirV2 (DictGer.raechen_V) ;
|
|
wreath_N = DictGer.kranz_N ;
|
|
wreck_N = DictGer.schrott_N ;
|
|
wren_N = DictGer.zaunkoenig_N ;
|
|
wrench_N = DictGer.schluessel_N ;
|
|
wriggle_V = DictGer.zappeln_V ;
|
|
wriggle_V2 = P.dirV2 (DictGer.zappeln_V) ;
|
|
wring_V2 = P.dirV2 (DictGer.wringen_V) ;
|
|
wrinkle_N = DictGer.falte_N ;
|
|
wrist_N = DictGer.handgelenk_N ;
|
|
wristwatch_N = DictGer.armbanduhr_N ;
|
|
writ_N = DictGer.verfuegung_N ;
|
|
write_V = DictGer.dichten_4_V ;
|
|
write_V2 = LexiconGer.write_V2 ;
|
|
writer_N = DictGer.autor_N ;
|
|
wrong_A = DictGer.schlecht_A ;
|
|
xylophone_N = DictGer.xylophon_N ;
|
|
yacht_N = DictGer.jacht_N ;
|
|
yak_N = DictGer.jak_N ;
|
|
yam_N = DictGer.yamswurzel_N ;
|
|
yank_N = DictGer.ruck_N ;
|
|
yard_N = DictGer.hof_N ;
|
|
yarn_N = DictGer.garn_N ;
|
|
yarrow_N = DictGer.schafgarbe_N ;
|
|
yashmak_N = DictGer.schleier_N ;
|
|
yawn_V = DictGer.gaehnen_V ;
|
|
year_N = LexiconGer.year_N ;
|
|
yearbook_N = DictGer.jahrbuch_N ;
|
|
yearly_A = DictGer.jaehrlich_A ;
|
|
yearn_V = DictGer.verlangen_V ;
|
|
yearning_N = DictGer.sehnsucht_N ;
|
|
yeast_N = DictGer.hefe_N ;
|
|
yell_V = DictGer.schreien_V ;
|
|
yell_V2 = P.dirV2 (DictGer.schreien_V) ;
|
|
yellow_A = LexiconGer.yellow_A ;
|
|
yellowish_A = DictGer.gelblich_A ;
|
|
yeti_N = DictGer.yeti_N ;
|
|
yew_N = DictGer.eibe_N ;
|
|
yield_V = DictGer.ergeben_V ;
|
|
yield_V2 = P.dirV2 (DictGer.ergeben_V) ;
|
|
yob_N = DictGer.rabauke_N ;
|
|
yodel_V = DictGer.jodeln_V ;
|
|
yodel_V2 = P.dirV2 (DictGer.jodeln_V) ;
|
|
yolk_N = DictGer.eigelb_N ;
|
|
young_A = LexiconGer.young_A ;
|
|
zeal_N = DictGer.begeisterung_N ;
|
|
zealot_N = DictGer.fanatiker_N ;
|
|
zealous_A = DictGer.eifrig_A ;
|
|
zebra_N = DictGer.zebra_N ;
|
|
zeppelin_N = DictGer.zeppelin_N ;
|
|
zest_N = DictGer.begeisterung_N ;
|
|
zigzag_N = DictGer.zickzack_N ;
|
|
zinc_N = DictGer.zync_N ;
|
|
zip_N = DictGer.postleitzahl_N ;
|
|
zither_N = DictGer.zither_N ;
|
|
zloty_N = DictGer.zloty_N ;
|
|
zombie_N = DictGer.zombie_N ;
|
|
zone_N = DictGer.bereich_N ;
|
|
zoo_N = DictGer.tiergarten_N ;
|
|
zoological_A = DictGer.zoologisch_A ;
|
|
zoologist_N = DictGer.zoologe__N ;
|
|
zoom_N = DictGer.aufstieg_N ;
|
|
|
|
|
|
-------
|
|
|
|
-- concrete StructuralGer of Structural = CatGer **
|
|
|
|
|
|
flags optimize=all ;
|
|
|
|
lin
|
|
|
|
above_Prep = mkPrep "über" P.dative ;
|
|
after_Prep = mkPrep "nach" P.dative ;
|
|
all_Predet = {s = appAdj (regA "all") ; c = noCase ; a = PAgNone} ;
|
|
almost_AdA, almost_AdN = ss "fast" ;
|
|
although_Subj = ss "obwohl" ;
|
|
always_AdV = ss "immer" ;
|
|
and_Conj = {s1 = [] ; s2 = "und" ; n = Pl} ;
|
|
because_Subj = ss "weil" ;
|
|
before_Prep = mkPrep "vor" P.dative ;
|
|
behind_Prep = mkPrep "hinter" P.dative ;
|
|
between_Prep = mkPrep "zwischen" P.dative ;
|
|
both7and_DConj = sd2 "sowohl" ["als auch"] ** {n = Pl} ;
|
|
but_PConj = ss "aber" ;
|
|
by8agent_Prep = mkPrep "durch" P.accusative ;
|
|
by8means_Prep = mkPrep "mit" P.dative ;
|
|
can8know_VV, can_VV = auxVV
|
|
(mkV
|
|
"können" "kann" "kannst" "kann" "könnt" "könn"
|
|
"konnte" "konntest" "konnten" "konntet"
|
|
"könnte" "gekonnt" []
|
|
VHaben) ;
|
|
during_Prep = mkPrep "während" P.genitive ;
|
|
either7or_DConj = sd2 "entweder" "oder" ** {n = Sg} ;
|
|
everybody_NP = nameNounPhrase {s = caselist "jeder" "jeden" "jedem" "jedes"} ;
|
|
every_Det = detLikeAdj False Sg "jed" ;
|
|
everything_NP = nameNounPhrase {s = caselist "alles" "alles" "allem" "alles"} ;
|
|
everywhere_Adv = ss "überall" ;
|
|
few_Det = detLikeAdj False Pl "wenig" ;
|
|
---- first_Ord = {s = (regA "erst").s ! Posit} ;
|
|
for_Prep = mkPrep "für" P.accusative ;
|
|
from_Prep = mkPrep "aus" P.dative ;
|
|
he_Pron = mkPronPers "er" "ihn" "ihm" "seiner" "sein" Masc Sg P3 ;
|
|
here7to_Adv = ss ["hierher"] ;
|
|
here7from_Adv = ss ["hieraus"] ;
|
|
here_Adv = ss "hier" ;
|
|
how_IAdv = ss "wie" ;
|
|
how8much_IAdv = ss "wieviel" ;
|
|
how8many_IDet = {s = \\g,c => (detLikeAdj False Pl "wieviel").s ! g ! NPC c ; n = Pl} ;
|
|
if_Subj = ss "wenn" ;
|
|
in8front_Prep = mkPrep "vor" P.dative ;
|
|
i_Pron = mkPronPers "ich" "mich" "mir" "meiner" "mein" Masc Sg P1 ;
|
|
in_Prep = mkPrep [] (NPP CInDat) ;
|
|
it_Pron = mkPronPers "es" "es" "ihm" "seiner" "sein" Neutr Sg P3 ;
|
|
less_CAdv = X.mkCAdv "weniger" "als" ;
|
|
many_Det = detLikeAdj False Pl "viel" ;
|
|
more_CAdv = X.mkCAdv "mehr" "als" ;
|
|
most_Predet = {s = appAdj (regA "meist") ; c = noCase ; a = PAgNone} ;
|
|
much_Det = detLikeAdj False Sg "viel" ;
|
|
must_VV = auxVV
|
|
(mkV
|
|
"müssen" "muß" "mußt" "muß" "müßt" "müß"
|
|
"mußte" "mußtest" "mußten" "mußtet"
|
|
"müßte" "gemußt" []
|
|
VHaben) ;
|
|
--- one_Quant = DEPREC
|
|
only_Predet = {s = \\_,_,_ => "nur" ; c = noCase ; a = PAgNone} ;
|
|
no_Utt = ss "nein" ;
|
|
---b no_Phr = ss "nein" ;
|
|
on_Prep = mkPrep "auf" P.dative ;
|
|
or_Conj = {s1 = [] ; s2 = "oder" ; n = Sg} ;
|
|
otherwise_PConj = ss "sonst" ;
|
|
part_Prep = P.von_Prep ; -- mkPrep "von" P.dative ;
|
|
please_Voc = ss "bitte" ;
|
|
possess_Prep = P.von_Prep ;-- mkPrep "von" P.dative ;
|
|
quite_Adv = ss "ziemlich" ;
|
|
she_Pron = mkPronPers "sie" "sie" "ihr" "ihrer" "ihr" Fem Sg P3 ;
|
|
so_AdA = ss "so" ;
|
|
somebody_NP = nameNounPhrase {s = caselist "jemand" "jemanden" "jemandem" "jemands"} ;
|
|
somePl_Det = detLikeAdj True Pl "einig" ;
|
|
someSg_Det = {
|
|
s,sp = \\g,c =>
|
|
usePrepC c (\k -> "ein" + pronEnding ! GSg g ! k) ; ---- einer,eines
|
|
n = Sg ;
|
|
a = Strong ;
|
|
hasNum = True ;
|
|
isDef = False ;
|
|
} ;
|
|
something_NP = nameNounPhrase {s = \\_ => "etwas"} ;
|
|
somewhere_Adv = ss "irgendwo" ;
|
|
that_Quant = let
|
|
jener : Number => Gender => PCase => Str = \\n => (detLikeAdj True n "jen").s in
|
|
{s = \\_ => jener ; sp = jener ; a,aPl = Weak} ;
|
|
---b that_NP = nameNounPhrase {s = caselist "das" "das" "denem" "dessen"} ; ----
|
|
there_Adv = ss "da" ;
|
|
there7to_Adv = ss "dahin" ;
|
|
there7from_Adv = ss ["daher"] ;
|
|
therefore_PConj = ss "deshalb" ;
|
|
---b these_NP = {s = caselist "diese" "diese" "diesen" "dieser" ; a = agrP3 Pl} ;
|
|
they_Pron = mkPronPers "sie" "sie" "ihnen" "ihrer" "ihr" Fem Pl P3 ;
|
|
this_Quant = let
|
|
dieser : Number => Gender => PCase => Str = \\n => (detLikeAdj True n "dies").s in
|
|
{s = \\_ => dieser ; sp = dieser ; a,aPl = Weak} ;
|
|
---b this_NP = nameNounPhrase {s = caselist "dies" "dies" "diesem" "dieses"} ; ----
|
|
---b those_NP = {s = caselist "jene" "jene" "jenen" "jener" ; a = agrP3 Pl} ;
|
|
through_Prep = mkPrep "durch" P.accusative ;
|
|
too_AdA = ss "zu" ;
|
|
to_Prep = mkPrep "nach" P.dative ;
|
|
under_Prep = mkPrep "unter" P.dative ;
|
|
very_AdA = ss "sehr" ;
|
|
{-
|
|
want_VV = auxVV
|
|
(mkV
|
|
"wollen" "will" "willst" "will" "wollt" "woll"
|
|
"wollte" "wolltest" "wollten" "wolltet"
|
|
"wollte" "gewollt" []
|
|
VHaben) ;
|
|
-}
|
|
we_Pron = mkPronPers "wir" "uns" "uns" "unser" "unser" Fem Pl P1 ;
|
|
|
|
whatSg_IP = {s = caselist "was" "was" "was" "wessen" ; n = Sg} ; ----
|
|
whatPl_IP = {s = caselist "was" "was" "was" "wessen" ; n = Pl} ; ----
|
|
|
|
when_IAdv = ss "wann" ;
|
|
when_Subj = ss "wenn" ;
|
|
where_IAdv = ss "wo" ;
|
|
which_IQuant = {s = \\n,g,c => (detLikeAdj True n "welch").s ! g ! NPC c} ;
|
|
|
|
whoSg_IP = {s = caselist "wer" "wen" "wem" "wessen" ; n = Sg} ;
|
|
whoPl_IP = {s = caselist "wer" "wen" "wem" "wessen" ; n = Pl} ;
|
|
why_IAdv = ss "warum" ;
|
|
without_Prep = mkPrep "ohne" P.accusative ;
|
|
with_Prep = mkPrep "mit" P.dative ;
|
|
youSg_Pron = mkPronPers "du" "dich" "dir" "deiner" "dein" Fem Sg P2 ;
|
|
youPl_Pron = mkPronPers "ihr" "euch" "euch" "eurer" "euer" Fem Pl P2 ; ---- poss
|
|
youPol_Pron = mkPronPers "Sie" "Sie" "Ihnen" "Ihrer" "Ihr" Fem Pl P3 ;
|
|
yes_Utt = ss "ja" ;
|
|
|
|
not_Predet = {s = \\_,_,_ => "nicht" ; c = noCase ; a = PAgNone} ;
|
|
no_Quant = let
|
|
keiner : Number => Gender => PCase => Str = table {
|
|
Sg => \\g,c => usePrepC c (\k -> "kein" + pronEnding ! GSg g ! k) ;
|
|
Pl => (detLikeAdj False Pl "kein").s
|
|
}
|
|
in
|
|
{s = \\_ => keiner ; sp = keiner ; a = Strong ; aPl = Weak} ; ---- sp
|
|
if_then_Conj = {s1 = "wenn" ; s2 = "dann" ; n = Sg ; lock_Conj = <>} ;
|
|
nobody_NP =
|
|
nameNounPhrase {s = caselist "niemand" "niemanden" "niemandem" "niemands"} ;
|
|
nothing_NP =
|
|
nameNounPhrase {s = \\_ => "nichts"} ;
|
|
at_least_AdN = ss "wenigstens" ;
|
|
at_most_AdN = ss "höchstens" ;
|
|
except_Prep = mkPrep "außer" P.dative ;
|
|
|
|
as_CAdv = X.mkCAdv "ebenso" "wie" ;
|
|
have_V2 = P.dirV2 IrregGer.haben_V ;
|
|
that_Subj = ss "daß" ;
|
|
|
|
lin language_title_Utt = ss "Deutsch" ;
|
|
|
|
}
|