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