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