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