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