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