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