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