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