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