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