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