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