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