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