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