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