diff --git a/libasn1parser/asn1parser.h b/libasn1parser/asn1parser.h
index ff7e410..d5a09a9 100644
--- a/libasn1parser/asn1parser.h
+++ b/libasn1parser/asn1parser.h
@@ -38,16 +38,16 @@
 #define	PRIuASN	"llu"	/* Or j? */
 #endif
 
-#include <asn1p_list.h>
-#include <asn1p_oid.h>		/* Object identifiers (OIDs) */
-#include <asn1p_ref.h>		/* References to custom types */
-#include <asn1p_value.h>	/* Value definition */
-#include <asn1p_param.h>	/* Parametrization */
-#include <asn1p_constr.h>	/* Type Constraints */
-#include <asn1p_xports.h>	/* IMports/EXports */
-#include <asn1p_module.h>	/* ASN.1 definition module */
-#include <asn1p_class.h>	/* CLASS-related stuff */
-#include <asn1p_expr.h>		/* A single ASN.1 expression */
+#include "asn1p_list.h"
+#include "asn1p_oid.h"		/* Object identifiers (OIDs) */
+#include "asn1p_ref.h"		/* References to custom types */
+#include "asn1p_value.h"	/* Value definition */
+#include "asn1p_param.h"	/* Parametrization */
+#include "asn1p_constr.h"	/* Type Constraints */
+#include "asn1p_xports.h"	/* IMports/EXports */
+#include "asn1p_module.h"	/* ASN.1 definition module */
+#include "asn1p_class.h"	/* CLASS-related stuff */
+#include "asn1p_expr.h"		/* A single ASN.1 expression */
 
 /*
  * Parser flags.
