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