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