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