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