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