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