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