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