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