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