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