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