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