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