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