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